CalculiX  2.8
A Free Software Three-Dimensional Structural Finite Element Program
 All Classes Files Functions Variables Macros
CalculiX.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define Linux   1
 
#define IRIX   2
 
#define IRIX64   3
 
#define HP   4
 
#define NNEW(a, b, c)   a=(b *)u_calloc((c),sizeof(b),__FILE__,__LINE__,#a)
 
#define RENEW(a, b, c)   a=(b *)u_realloc((b *)(a),(c)*sizeof(b),__FILE__,__LINE__,#a)
 
#define SFREE(a)   u_free(a,__FILE__,__LINE__,#a)
 
#define DMEMSET(a, b, c, d)   for(im=b;im<c;im++)a[im]=d
 
#define ITG   int
 
#define ITGFORMAT   "d"
 

Functions

void FORTRAN (addimdnodecload,(ITG *nodeforc, ITG *i, ITG *imdnode, ITG *nmdnode, double *xforc, ITG *ikmpc, ITG *ilmpc, ITG *ipompc, ITG *nodempc, ITG *nmpc, ITG *imddof, ITG *nmddof, ITG *nactdof, ITG *mi, ITG *imdmpc, ITG *nmdmpc, ITG *imdboun, ITG *nmdboun, ITG *ikboun, ITG *nboun, ITG *ilboun, ITG *ithermal))
 
void FORTRAN (addimdnodedload,(ITG *nelemload, char *sideload, ITG *ipkon, ITG *kon, char *lakon, ITG *i, ITG *imdnode, ITG *nmdnode, ITG *ikmpc, ITG *ilmpc, ITG *ipompc, ITG *nodempc, ITG *nmpc, ITG *imddof, ITG *nmddof, ITG *nactdof, ITG *mi, ITG *imdmpc, ITG *nmdmpc, ITG *imdboun, ITG *nmdboun, ITG *ikboun, ITG *nboun, ITG *ilboun, ITG *ithermal))
 
void FORTRAN (addizdofcload,(ITG *nodeforc, ITG *ndirforc, ITG *nactdof, ITG *mi, ITG *izdof, ITG *nzdof, ITG *i, ITG *iznode, ITG *nznode, ITG *nk, ITG *imdnode, ITG *nmdnode, double *xforc))
 
void FORTRAN (addizdofdload,(ITG *nelemload, char *sideload, ITG *ipkon, ITG *kon, char *lakon, ITG *nactdof, ITG *izdof, ITG *nzdof, ITG *mi, ITG *i, ITG *iznode, ITG *nznode, ITG *nk, ITG *imdnode, ITG *nmdnode))
 
void FORTRAN (adjustcontactnodes,(char *tieset, ITG *ntie, ITG *itietri, double *cg, double *straight, double *co, double *vold, double *xo, double *yo, double *zo, double *x, double *y, double *z, ITG *nx, ITG *ny, ITG *nz, ITG *istep, ITG *iinc, ITG *iit, ITG *mi, ITG *imastop, ITG *nslavnode, ITG *islavnode, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, double *tietol, double *clearini, double *clearslavnode, ITG *itiefac, ITG *ipkon, ITG *kon, char *lakon, ITG *islavsurf))
 
void FORTRAN (allocation,(ITG *nload_, ITG *nforc_, ITG *nboun_, ITG *nk_, ITG *ne_, ITG *nmpc_, ITG *nset_, ITG *nalset_, ITG *nmat_, ITG *ntmat_, ITG *npmat_, ITG *norien_, ITG *nam_, ITG *nprint_, ITG *mi, ITG *ntrans_, char *set, ITG *meminset, ITG *rmeminset, ITG *ncs_, ITG *namtot_, ITG *ncmat_, ITG *memmpc_, ITG *ne1d, ITG *ne2d, ITG *nflow, char *jobnamec, ITG *irstrt, ITG *ithermal, ITG *nener, ITG *nstate_, ITG *istep, char *inpc, ITG *ipoinp, ITG *inp, ITG *ntie_, ITG *nbody_, ITG *nprop_, ITG *ipoinpc, ITG *nevdamp, ITG *npt_, ITG *nslavsm, ITG *nkon_, ITG *mcs, ITG *mortar, ITG *ifacecount, ITG *nintpoint, ITG *infree, ITG *nheading_))
 
void FORTRAN (allocont,(ITG *ncont, ITG *ntie, char *tieset, ITG *nset, char *set, ITG *istartset, ITG *iendset, ITG *ialset, char *lakon, ITG *ncone, double *tietol, ITG *ismallsliding, char *kind1, char *kind2, ITG *mortar, ITG *istep))
 
void FORTRAN (applyboun,(ITG *ifaext, ITG *nfaext, ITG *ielfa, ITG *ikboun, ITG *ilboun, ITG *nboun, char *typeboun, ITG *nelemload, ITG *nload, char *sideload, ITG *isolidsurf, ITG *nsolidsurf, ITG *ifabou, ITG *nfabou, ITG *nface, ITG *nodeboun, ITG *ndirboun, ITG *ikmpc, ITG *ilmpc, char *labmpc, ITG *nmpc, ITG *nactdohinv))
 
void FORTRAN (applympc,(ITG *nface, ITG *ielfa, ITG *is, ITG *ie, ITG *ifabou, ITG *ipompc, double *vfa, double *coefmpc, ITG *nodempc, ITG *ipnei, ITG *neifa, char *labmpc, double *xbounact, ITG *nactdoh))
 
void arpack (double *co, ITG *nk, ITG **konp, ITG **ipkonp, char **lakonp, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, ITG *nactdof, ITG *icol, ITG *jq, ITG **irowp, ITG *neq, ITG *nzl, ITG *nmethod, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *shcon, ITG *nshcon, double *cocon, ITG *ncocon, double *alcon, ITG *nalcon, double *alzero, ITG **ielmatp, ITG **ielorienp, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, double *t1old, ITG *ithermal, double *prestr, ITG *iprestr, double *vold, ITG *iperturb, double *sti, ITG *nzs, ITG *kode, ITG *mei, double *fei, char *filab, double *eme, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double **xstatep, ITG *npmat_, char *matname, ITG *mi, ITG *ncmat_, ITG *nstate_, double **enerp, char *jobnamec, char *output, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nprint, char *prlab, char *prset, ITG *nener, ITG *isolver, double *trab, ITG *inotr, ITG *ntrans, double *ttime, double *fmpc, char *cbody, ITG *ibody, double *xbody, ITG *nbody, double *thicke, ITG *nslavs, double *tietol, ITG *nkon, ITG *mpcinfo, ITG *ntie, ITG *istep, ITG *mcs, ITG *ics, char *tieset, double *cs, ITG *nintpoint, ITG *mortar, ITG *ifacecount, ITG **islavsurfp, double **pslavsurfp, double **clearinip, ITG *nmat, char *typeboun, ITG *ielprop, double *prop)
 
void arpackbu (double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, ITG *nactdof, ITG *icol, ITG *jq, ITG *irow, ITG *neq, ITG *nzl, ITG *nmethod, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, double *t1old, ITG *ithermal, double *prestr, ITG *iprestr, double *vold, ITG *iperturb, double *sti, ITG *nzs, ITG *kode, ITG *mei, double *fei, char *filab, double *eme, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstate, ITG *npmat_, char *matname, ITG *mi, ITG *ncmat_, ITG *nstate_, double *ener, char *output, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nprint, char *prlab, char *prset, ITG *nener, ITG *isolver, double *trab, ITG *inotr, ITG *ntrans, double *ttime, double *fmpc, char *cbody, ITG *ibody, double *xbody, ITG *nbody, double *thicke, char *jobnamec, ITG *nmat, ITG *ielprop, double *prop)
 
void arpackcs (double *co, ITG *nk, ITG **konp, ITG **ipkonp, char **lakonp, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, ITG *nactdof, ITG *icol, ITG *jq, ITG **irowp, ITG *neq, ITG *nzl, ITG *nmethod, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG **ielmatp, ITG **ielorienp, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, double *t1old, ITG *ithermal, double *prestr, ITG *iprestr, double *vold, ITG *iperturb, double *sti, ITG *nzs, ITG *kode, ITG *mei, double *fei, char *filab, double *eme, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double **xstatep, ITG *npmat_, char *matname, ITG *mi, ITG *ics, double *cs, ITG *mpcend, ITG *ncmat_, ITG *nstate_, ITG *mcs, ITG *nkon, double **enerp, char *jobnamec, char *output, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nprint, char *prlab, char *prset, ITG *nener, ITG *isolver, double *trab, ITG *inotr, ITG *ntrans, double *ttime, double *fmpc, char *cbody, ITG *ibody, double *xbody, ITG *nbody, ITG *nevtot, double *thicke, ITG *nslavs, double *tietol, ITG *mpcinfo, ITG *ntie, ITG *istep, char *tieset, ITG *nintpoint, ITG *mortar, ITG *ifacecount, ITG **islavsurfp, double **pslavsurfp, double **clearinip, ITG *nmat, char *typeboun, ITG *ielprop, double *prop)
 
void FORTRAN (assigndomtonodes,(ITG *ne, char *lakon, ITG *ipkon, ITG *kon, ITG *ielmat, ITG *inomat, double *elcon, ITG *ncmat_, ITG *ntmat_, ITG *mi, ITG *ne2))
 
void FORTRAN (basis,(double *x, double *y, double *z, double *xo, double *yo, double *zo, ITG *nx, ITG *ny, ITG *nz, double *planfa, ITG *ifatet, ITG *nktet, ITG *netet, double *field, ITG *nfield, double *cotet, ITG *kontyp, ITG *ipkon, ITG *kon, ITG *iparent, double *xp, double *yp, double *zp, double *value, double *ratio, ITG *iselect, ITG *nselect, ITG *istartset, ITG *iendset, ITG *ialset, ITG *imastset, ITG *ielemnr, ITG *nterms, ITG *konl))
 
void biosav (ITG *ipkon, ITG *kon, char *lakon, ITG *ne, double *co, double *qfx, double *h0, ITG *mi, ITG *inomat, ITG *nk)
 
void FORTRAN (biotsavart,(ITG *ipkon, ITG *kon, char *lakon, ITG *ne, double *co, double *qfx, double *h0, ITG *mi, ITG *nka, ITG *nkb))
 
void * biotsavartmt (ITG *i)
 
void FORTRAN (bodyforce,(char *cbody, ITG *ibody, ITG *ipobody, ITG *nbody, char *set, ITG *istartset, ITG *iendset, ITG *ialset, ITG *inewton, ITG *nset, ITG *ifreebody, ITG *k))
 
void FORTRAN (calcbody,(ITG *nef, double *body, ITG *ipobody, ITG *ibody, double *xbody, double *coel, double *vel, char *lakon, ITG *nactdohinv))
 
void FORTRAN (calcguesstincf,(ITG *nface, double *dmin, double *vfa, double *umfa, double *tincfguess))
 
void FORTRAN (calccpel,(ITG *nef, double *vel, double *shcon, ITG *nshcon, ITG *ielmat, ITG *ntmat_, ITG *mi, double *cpel, double *physcon))
 
void FORTRAN (calccpfa,(ITG *nface, double *vfa, double *shcon, ITG *nshcon, ITG *ielmat, ITG *ntmat_, ITG *mi, ITG *ielfa, double *cpfa, double *physcon))
 
void FORTRAN (calcgamma,(ITG *nface, ITG *ielfa, double *vel, double *gradvfa, double *gamma, double *xlet, double *xxn, double *xxj, ITG *ipnei, double *betam, ITG *nef))
 
void FORTRAN (calcgammat,(ITG *nface, ITG *ielfa, double *vel, double *gradtfa, double *gammat, double *xlet, double *xxn, double *xxj, ITG *ipnei, double *betam, ITG *nef))
 
void FORTRAN (calcgradpel,(ITG *ne, char *lakon, ITG *ipnei, double *vfa, double *area, double *xxn, double *gradpel, ITG *neifa, double *volume))
 
void FORTRAN (calcgradtel,(ITG *ne, char *lakon, ITG *ipnei, double *vfa, double *area, double *xxn, double *gradtel, ITG *neifa, double *volume))
 
void FORTRAN (calcgradvel,(ITG *ne, char *lakon, ITG *ipnei, double *vfa, double *area, double *xxn, double *gradv, ITG *neifa, double *volume))
 
void FORTRAN (calchcfa,(ITG *nface, double *vfa, double *cocon, ITG *ncocon, ITG *ielmat, ITG *ntmat_, ITG *mi, ITG *ielfa, double *hcfa))
 
void FORTRAN (calch0interface,(ITG *nmpc, ITG *ipompc, ITG *nodempc, double *coefmpc, double *h0))
 
void FORTRAN (calcmac,(ITG *neq, double *z, double *zz, ITG *nev, double *mac, double *maccpx, ITG *istartnmd, ITG *iendnmd, ITG *nmd, ITG *cyclicsymmetry, ITG *neqact, double *bett, double *betm))
 
void FORTRAN (calcmass,(ITG *ipkon, char *lakon, ITG *kon, double *co, ITG *mi, ITG *nelem, ITG *ne, double *thicke, ITG *ielmat, ITG *nope, double *t0, double *t1, double *rhcon, ITG *nrhcon, ITG *ntmat_, ITG *ithermal, double *csmass))
 
void calcresidual (ITG *nmethod, ITG *neq, double *b, double *fext, double *f, ITG *iexpl, ITG *nactdof, double *aux2, double *vold, double *vini, double *dtime, double *accold, ITG *nk, double *adb, double *aub, ITG *icol, ITG *irow, ITG *nzl, double *alpha, double *fextini, double *fini, ITG *islavnode, ITG *nslavnode, ITG *mortar, ITG *ntie, double *f_cm, double *f_cs, ITG *mi, ITG *nzs, ITG *nasym, ITG *idamping, double *veold, double *adc, double *auc, double *cvini, double *cv)
 
void calcresidual_em (ITG *nmethod, ITG *neq, double *b, double *fext, double *f, ITG *iexpl, ITG *nactdof, double *aux1, double *aux2, double *vold, double *vini, double *dtime, double *accold, ITG *nk, double *adb, double *aub, ITG *icol, ITG *irow, ITG *nzl, double *alpha, double *fextini, double *fini, ITG *islavnode, ITG *nslavnode, ITG *mortar, ITG *ntie, double *f_cm, double *f_cs, ITG *mi, ITG *nzs, ITG *nasym, ITG *ithermal)
 
void FORTRAN (calcpel,(ITG *ne, ITG *nactdoh, double *vel, double *b, ITG *nef))
 
void FORTRAN (calcrhoel,(ITG *nef, double *vel, double *rhcon, ITG *nrhcon, ITG *ielmat, ITG *ntmat_, ITG *ithermal, ITG *mi))
 
void FORTRAN (calcrhofa,(ITG *nface, double *vfa, double *rhcon, ITG *nrhcon, ITG *ielmat, ITG *ntmat_, ITG *ithermal, ITG *mi, ITG *ielfa))
 
void FORTRAN (calctel,(ITG *ne, ITG *nactdoh, double *vel, double *b, ITG *nef))
 
void FORTRAN (calcumel,(ITG *nef, double *vel, double *shcon, ITG *nshcon, ITG *ielmat, ITG *ntmat_, ITG *ithermal, ITG *mi, double *umel))
 
void FORTRAN (calcumfa,(ITG *nface, double *vfa, double *shcon, ITG *nshcon, ITG *ielmat, ITG *ntmat_, ITG *ithermal, ITG *mi, ITG *ielfa, double *umfa))
 
void FORTRAN (calcvel,(ITG *ne, ITG *nactdoh, double *vel, double *b, ITG *neq, ITG *nef))
 
void FORTRAN (calcview,(char *sideload, double *vold, double *co, double *pmid, double *e1, double *e2, double *e3, ITG *kontri, ITG *nloadtr, double *adview, double *auview, double *dist, ITG *idist, double *area, ITG *ntrit, ITG *mi, ITG *jqrad, ITG *irowrad, ITG *nzsrad, double *sidemean, ITG *ntria, ITG *ntrib))
 
void * calcviewmt (ITG *i)
 
void FORTRAN (calinput,(double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *nkon, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, ITG *nmpc, ITG *nmpc_, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nforc_, ITG *nelemload, char *sideload, double *xload, ITG *nload, ITG *nload_, ITG *nprint, char *prlab, char *prset, ITG *mpcfree, ITG *nboun_, ITG *mei, char *set, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nset, ITG *nalset, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, double *t0, double *t1, char *matname, ITG *ielmat, char *orname, double *orab, ITG *ielorien, char *amname, double *amta, ITG *namta, ITG *nam, ITG *nmethod, ITG *iamforc, ITG *iamload, ITG *iamt1, ITG *ithermal, ITG *iperturb, ITG *istat, ITG *istep, ITG *nmat, ITG *ntmat_, ITG *norien, double *prestr, ITG *iprestr, ITG *isolver, double *fei, double *veold, double *timepar, double *xmodal, char *filab, ITG *jout, ITG *nlabel, ITG *idrct, ITG *jmax, ITG *iexpl, double *alpha, ITG *iamboun, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, ITG *iplas, ITG *npmat_, ITG *mi, ITG *nk_, double *trab, ITG *inotr, ITG *ntrans, ITG *ikboun, ITG *ilboun, ITG *ikmpc, ITG *ilmpc, ITG *ics, double *dcs, ITG *ncs_, ITG *namtot_, double *cs, ITG *nstate_, ITG *ncmat_, ITG *iumat, ITG *mcs, char *labmpc, ITG *iponor, double *xnor, ITG *knor, double *thickn, double *thicke, ITG *ikforc, ITG *ilforc, double *offset, ITG *iponoel, ITG *inoel, ITG *rig, ITG *infree, ITG *nshcon, double *shcon, double *cocon, ITG *ncocon, double *physcon, ITG *nflow, double *ctrl, ITG *maxlenmpc, ITG *ne1d, ITG *ne2d, ITG *nener, double *vold, ITG *nodebounold, ITG *ndirbounold, double *xbounold, double *xforcold, double *xloadold, double *t1old, double *eme, double *sti, double *ener, double *xstate, char *jobnamec, ITG *irstrt, double *ttime, double *qaold, char *output, char *typeboun, char *inpc, ITG *ipoinp, ITG *inp, char *tieset, double *tietol, ITG *ntie, double *fmpc, char *cbody, ITG *ibody, double *xbody, ITG *nbody, ITG *nbody_, double *xbodyold, ITG *nam_, ITG *ielprop, ITG *nprop, ITG *nprop_, double *prop, ITG *itpamp, ITG *iviewfile, ITG *ipoinpc, ITG *cfd, ITG *nslavs, double *t0g, double *t1g, ITG *network, ITG *cyclicsymmetry, ITG *idefforc, ITG *idefload, ITG *idefbody, ITG *mortar, ITG *ifacecount, ITG *islavsurf, double *pslavsurf, double *clearini, char *heading, ITG *iaxial))
 
void cascade (ITG *ipompc, double **coefmpcp, ITG **nodempcp, ITG *nmpc, ITG *mpcfree, ITG *nodeboun, ITG *ndirboun, ITG *nboun, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, ITG *mpcend, ITG *mpcmult, char *labmpc, ITG *nk, ITG *memmpc_, ITG *icascade, ITG *maxlenmpc, ITG *callfrommain, ITG *iperturb, ITG *ithermal)
 
void FORTRAN (cataloguenodes,(ITG *iponofa, ITG *inofa, ITG *ifreefa, ITG *ielfa, ITG *ifaboun, ITG *ipkon, ITG *kon, char *lakon, ITG *nface, ITG *ne))
 
ITG cgsolver (double *A, double *x, double *b, ITG neq, ITG len, ITG *ia, ITG *iz, double *eps, ITG *niter, ITG precFlg)
 
void checkconvergence (double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, double *stn, ITG *nmethod, ITG *kode, char *filab, double *een, double *t1act, double *time, double *epn, ITG *ielmat, char *matname, double *enern, double *xstaten, ITG *nstate_, ITG *istep, ITG *iinc, ITG *iperturb, double *ener, ITG *mi, char *output, ITG *ithermal, double *qfn, ITG *mode, ITG *noddiam, double *trab, ITG *inotr, ITG *ntrans, double *orab, ITG *ielorien, ITG *norien, char *description, double *sti, ITG *icutb, ITG *iit, double *dtime, double *qa, double *vold, double *qam, double *ram1, double *ram2, double *ram, double *cam, double *uam, ITG *ntg, double *ttime, ITG *icntrl, double *theta, double *dtheta, double *veold, double *vini, ITG *idrct, double *tper, ITG *istab, double *tmax, ITG *nactdof, double *b, double *tmin, double *ctrl, double *amta, ITG *namta, ITG *itpamp, ITG *inext, double *dthetaref, ITG *itp, ITG *jprint, ITG *jout, ITG *uncoupled, double *t1, ITG *iitterm, ITG *nelemload, ITG *nload, ITG *nodeboun, ITG *nboun, ITG *itg, ITG *ndirboun, double *deltmx, ITG *iflagact, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, double *emn, double *thicke, char *jobnamec, ITG *mortar, ITG *nmat, ITG *ielprop, double *prop)
 
void checkconvnet (ITG *icutb, ITG *iin, double *qamt, double *qamf, double *qamp, double *ram1t, double *ram1f, double *ram1p, double *ram2t, double *ram2f, double *ram2p, double *ramt, double *ramf, double *ramp, ITG *icntrl, double *dtheta, double *ctrl, double *uama, double *ram1a, double *ram2a, double *rama, double *vamt, double *vamf, double *vamp, double *vama)
 
void checkinclength (double *time, double *ttime, double *theta, double *dtheta, ITG *idrct, double *tper, double *tmax, double *tmin, double *ctrl, double *amta, ITG *namta, ITG *itpamp, ITG *inext, double *dthetaref, ITG *itp, ITG *jprint, ITG *jout)
 
void FORTRAN (checktime,(ITG *itpamp, ITG *namta, double *tinc, double *ttime, double *amta, double *tmin, ITG *inext, ITG *itp, ITG *istep))
 
void FORTRAN (checktruecontact,(ITG *ntie, char *tieset, double *tietol, double *elcon, ITG *itruecontact, ITG *ncmat_, ITG *ntmat_))
 
void FORTRAN (closefile,())
 
void FORTRAN (closefilefluid,())
 
void compfluid (double **cop, ITG *nk, ITG **ipkonp, ITG **konp, char **lakonp, char **sideface, ITG *ifreestream, ITG *nfreestream, ITG *isolidsurf, ITG *neighsolidsurf, ITG *nsolidsurf, ITG **iponoel, ITG **inoel, ITG *nshcon, double *shcon, ITG *nrhcon, double *rhcon, double **voldp, ITG *ntmat_, ITG *nodeboun, ITG *ndirboun, ITG *nboun, ITG **ipompcp, ITG **nodempcp, ITG *nmpc, ITG **ikmpcp, ITG **ilmpcp, ITG *ithermal, ITG *ikboun, ITG *ilboun, ITG *turbulent, ITG *isolver, ITG *iexpl, double *vcontu, double *ttime, double *time, double *dtime, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, double *xbody, ITG *ipobody, ITG *nbody, ITG *ielmat, char *matname, ITG *mi, ITG *ncmat_, double *physcon, ITG *istep, ITG *iinc, ITG *ibody, double *xloadold, double *xboun, double **coefmpcp, ITG *nmethod, double *xforcold, double *xforcact, ITG *iamforc, ITG *iamload, double *xbodyold, double *xbodyact, double *t1old, double *t1, double *t1act, ITG *iamt1, double *amta, ITG *namta, ITG *nam, double *ampli, double *xbounold, double *xbounact, ITG *iamboun, ITG *itg, ITG *ntg, char *amname, double *t0, ITG **nelemface, ITG *nface, double *cocon, ITG *ncocon, double *xloadact, double *tper, ITG *jmax, ITG *jout, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, char *prset, char *prlab, ITG *nprint, double *trab, ITG *inotr, ITG *ntrans, char *filab, char **labmpcp, double *sti, ITG *norien, double *orab, char *jobnamef, char *tieset, ITG *ntie, ITG *mcs, ITG *ics, double *cs, ITG *nkon, ITG *mpcfree, ITG *memmpc_, double **fmpcp, ITG *nef, ITG **inomat, double *qfx, ITG *neifa, ITG *neiel, ITG *ielfa, ITG *ifaext, double *vfa, double *vel, ITG *ipnei, ITG *nflnei, ITG *nfaext, char *typeboun, ITG *neij, double *tincf, ITG *nactdoh, ITG *nactdohinv, ITG *ielorien)
 
void FORTRAN (complete_hel,(ITG *neq, double *b, double *hel, double *ad, double *au, ITG *jq, ITG *irow, ITG *nzs))
 
void complexfreq (double **cop, ITG *nk, ITG **konp, ITG **ipkonp, char **lakonp, ITG *ne, ITG **nodebounp, ITG **ndirbounp, double **xbounp, ITG *nboun, ITG **ipompcp, ITG **nodempcp, double **coefmpcp, char **labmpcp, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, ITG **nactdofp, ITG *neq, ITG *nzl, ITG *icol, ITG *irow, ITG *nmethod, ITG **ikmpcp, ITG **ilmpcp, ITG **ikbounp, ITG **ilbounp, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *cocon, ITG *ncocon, double *alcon, ITG *nalcon, double *alzero, ITG **ielmatp, ITG **ielorienp, ITG *norien, double *orab, ITG *ntmat_, double **t0p, double **t1p, ITG *ithermal, double *prestr, ITG *iprestr, double **voldp, ITG *iperturb, double **stip, ITG *nzs, double *timepar, double *xmodal, double **veoldp, char *amname, double *amta, ITG *namta, ITG *nam, ITG *iamforc, ITG *iamload, ITG **iamt1p, ITG *jout, ITG *kode, char *filab, double **emep, double *xforcold, double *xloadold, double **t1oldp, ITG **iambounp, double **xbounoldp, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstate, ITG *npmat_, char *matname, ITG *mi, ITG *ncmat_, ITG *nstate_, double **enerp, char *jobnamec, double *ttime, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG **ialsetp, ITG *nprint, char *prlab, char *prset, ITG *nener, double *trab, ITG **inotrp, ITG *ntrans, double **fmpcp, char *cbody, ITG *ibody, double *xbody, ITG *nbody, double *xbodyold, ITG *istep, ITG *isolver, ITG *jq, char *output, ITG *mcs, ITG *nkon, ITG *mpcend, ITG *ics, double *cs, ITG *ntie, char *tieset, ITG *idrct, ITG *jmax, double *ctrl, ITG *itpamp, double *tietol, ITG *nalset, ITG *ikforc, ITG *ilforc, double *thicke, char *jobnamef, ITG *mei, ITG *nmat, ITG *ielprop, double *prop)
 
void contact (ITG *ncont, ITG *ntie, char *tieset, ITG *nset, char *set, ITG *istartset, ITG *iendset, ITG *ialset, ITG *itietri, char *lakon, ITG *ipkon, ITG *kon, ITG *koncont, ITG *ne, double *cg, double *straight, ITG *ifree, double *co, double *vold, ITG *ielmat, double *cs, double *elcon, ITG *istep, ITG *iinc, ITG *iit, ITG *ncmat_, ITG *ntmat_, ITG *ne0, double *vini, ITG *nmethod, ITG *nmpc, ITG *mpcfree, ITG *memmpc_, ITG **ipompcp, char **labmpcp, ITG **ikmpcp, ITG **ilmpcp, double **fmpcp, ITG **nodempcp, double **coefmpcp, ITG *iperturb, ITG *ikboun, ITG *nboun, ITG *mi, ITG *imastop, ITG *nslavnode, ITG *islavnode, ITG *islavsurf, ITG *itiefac, double *areaslav, ITG *iponoels, ITG *inoels, double *springarea, double *tietol, double *reltime, ITG *imastnode, ITG *nmastnode, double *xmastnor, char *filab, ITG *mcs, ITG *ics, ITG *nasym, double *xnoels, ITG *mortar, double *pslavsurf, double *pmastsurf, double *clearini, double *theta)
 
void FORTRAN (convert2slapcol,(double *au, double *ad, ITG *irow, ITG *ia, ITG *jq, ITG *ja, ITG *nzs, ITG *neq, double *aua))
 
void FORTRAN (coriolissolve,(double *cc, ITG *nev, double *aa, double *bb, double *xx, double *eiga, double *eigb, double *eigxx, ITG *iter, double *d, double *temp))
 
void FORTRAN (correctvel,(double *hel, double *adv, double *vfa, ITG *ipnei, double *area, double *bv, double *xxn, ITG *neifa, char *lakon, ITG *ne, ITG *neq))
 
void FORTRAN (correctvfa,(ITG *nface, ITG *ielfa, double *area, double *vfa, double *ap, double *bp, double *xxn, ITG *ifabou, ITG *ipnei, ITG *nef, ITG *neifa, double *hfa, double *vel, double *xboun))
 
void FORTRAN (createinterfacempcs,(ITG *imastnode, double *xmastnor, ITG *nmastnode, ITG *ikmpc, ITG *ilmpc, ITG *nmpc, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *mpcfree, ITG *ikboun, ITG *nboun))
 
void FORTRAN (createinum,(ITG *ipkon, ITG *inum, ITG *kon, char *lakon, ITG *nk, ITG *ne, char *cflag, ITG *nelemload, ITG *nload, ITG *nodeboun, ITG *nboun, ITG *ndirboun, ITG *ithermal, double *co, double *vold, ITG *mi, ITG *ielmat))
 
void FORTRAN (createmddof,(ITG *imddof, ITG *nmddof, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nactdof, ITG *ithermal, ITG *mi, ITG *imdnode, ITG *nmdnode, ITG *ikmpc, ITG *ilmpc, ITG *ipompc, ITG *nodempc, ITG *nmpc, ITG *imdmpc, ITG *nmdmpc, ITG *imdboun, ITG *nmdboun, ITG *ikboun, ITG *nboun, ITG *nset, ITG *ntie, char *tieset, char *set, char *lakon, ITG *kon, ITG *ipkon, char *labmpc, ITG *ilboun, char *filab, char *prlab, char *prset, ITG *nprint, ITG *ne, ITG *cyclicsymmetry))
 
void FORTRAN (createmdelem,(ITG *imdnode, ITG *nmdnode, double *xforc, ITG *ikmpc, ITG *ilmpc, ITG *ipompc, ITG *nodempc, ITG *nmpc, ITG *imddof, ITG *nmddof, ITG *nactdof, ITG *mi, ITG *imdmpc, ITG *nmdmpc, ITG *imdboun, ITG *nmdboun, ITG *ikboun, ITG *nboun, ITG *ilboun, ITG *ithermal, ITG *imdelem, ITG *nmdelem, ITG *iponoel, ITG *inoel, char *prlab, char *prset, ITG *nprint, char *lakon, char *set, ITG *nset, ITG *ialset, ITG *ipkon, ITG *kon, ITG *istartset, ITG *iendset, ITG *nforc, ITG *ikforc, ITG *ilforc))
 
void FORTRAN (createtiedsurfs,(ITG *nodface, ITG *ipoface, char *set, ITG *istartset, ITG *iendset, ITG *ialset, char *tieset, ITG *inomat, ITG *ne, ITG *ipkon, char *lakon, ITG *kon, ITG *ntie, double *tietol, ITG *nalset, ITG *nk, ITG *nset, ITG *iactive))
 
void FORTRAN (dattime,(char *date, char *clock))
 
void CEE (ddotc,(ITG *n, double *dx, ITG *incx, double *dy, ITG *incy, double *funcddot))
 
void * ddotc1mt (ITG *i)
 
void dfdbj (double *bcont, double **dbcontp, ITG *neq, ITG *nope, ITG *konl, ITG *nactdof, double *s, double *z, ITG *ikmpc, ITG *ilmpc, ITG *ipompc, ITG *nodempc, ITG *nmpc, double *coefmpc, double *fnl, ITG *nev, ITG **ikactcontp, ITG **ilactcontp, ITG *nactcont, ITG *nactcont_, ITG *mi, ITG *cyclicsymmetry, ITG *izdof, ITG *nzdof)
 
void FORTRAN (dgesv,(ITG *nteq, ITG *nhrs, double *ac, ITG *lda, ITG *ipiv, double *bc, ITG *ldb, ITG *info))
 
void FORTRAN (dgetrs,(char *trans, ITG *nteq, ITG *nrhs, double *ac, ITG *lda, ITG *ipiv, double *bc, ITG *ldb, ITG *info))
 
void FORTRAN (drfftf,(ITG *ndata, double *r, double *wsave, ITG *isave))
 
void FORTRAN (drffti,(ITG *ndata, double *wsave, ITG *isave))
 
void FORTRAN (dnaupd,(ITG *ido, char *bmat, ITG *n, char *which, ITG *nev, double *tol, double *resid, ITG *ncv, double *z, ITG *ldz, ITG *iparam, ITG *ipntr, double *workd, double *workl, ITG *lworkl, ITG *info))
 
void FORTRAN (dsaupd,(ITG *ido, char *bmat, ITG *n, char *which, ITG *nev, double *tol, double *resid, ITG *ncv, double *z, ITG *ldz, ITG *iparam, ITG *ipntr, double *workd, double *workl, ITG *lworkl, ITG *info))
 
void FORTRAN (dneupd,(ITG *rvec, char *howmny, ITG *select, double *d, double *di, double *z, ITG *ldz, double *sigma, double *sigmai, double *workev, char *bmat, ITG *neq, char *which, ITG *nev, double *tol, double *resid, ITG *ncv, double *v, ITG *ldv, ITG *iparam, ITG *ipntr, double *workd, double *workl, ITG *lworkl, ITG *info))
 
void FORTRAN (dseupd,(ITG *rvec, char *howmny, ITG *select, double *d, double *z, ITG *ldz, double *sigma, char *bmat, ITG *neq, char *which, ITG *nev, double *tol, double *resid, ITG *ncv, double *v, ITG *ldv, ITG *iparam, ITG *ipntr, double *workd, double *workl, ITG *lworkl, ITG *info))
 
void FORTRAN (dsort,(double *dx, ITG *iy, ITG *n, ITG *kflag))
 
void dyna (double **cop, ITG *nk, ITG **konp, ITG **ipkonp, char **lakonp, ITG *ne, ITG **nodebounp, ITG **ndirbounp, double **xbounp, ITG *nboun, ITG **ipompcp, ITG **nodempcp, double **coefmpcp, char **labmpcp, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, ITG **nactdofp, ITG *neq, ITG *nzl, ITG *icol, ITG *irow, ITG *nmethod, ITG **ikmpcp, ITG **ilmpcp, ITG **ikbounp, ITG **ilbounp, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *cocon, ITG *ncocon, double *alcon, ITG *nalcon, double *alzero, ITG **ielmatp, ITG **ielorienp, ITG *norien, double *orab, ITG *ntmat_, double **t0p, double **t1p, ITG *ithermal, double *prestr, ITG *iprestr, double **voldp, ITG *iperturb, double **stip, ITG *nzs, double *timepar, double *xmodal, double **veoldp, char *amname, double *amta, ITG *namta, ITG *nam, ITG *iamforc, ITG *iamload, ITG **iamt1p, ITG *jout, ITG *kode, char *filab, double **emep, double *xforcold, double *xloadold, double **t1oldp, ITG **iambounp, double **xbounoldp, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double **xstatep, ITG *npmat_, char *matname, ITG *mi, ITG *ncmat_, ITG *nstate_, double **enerp, char *jobnamec, double *ttime, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG **ialsetp, ITG *nprint, char *prlab, char *prset, ITG *nener, double *trab, ITG **inotrp, ITG *ntrans, double **fmpcp, char *cbody, ITG *ibody, double *xbody, ITG *nbody, double *xbodyold, ITG *istep, ITG *isolver, ITG *jq, char *output, ITG *mcs, ITG *nkon, ITG *mpcend, ITG *ics, double *cs, ITG *ntie, char *tieset, ITG *idrct, ITG *jmax, double *ctrl, ITG *itpamp, double *tietol, ITG *nalset, ITG *ikforc, ITG *ilforc, double *thicke, ITG *nslavs, ITG *nmat, char *typeboun, ITG *ielprop, double *prop)
 
void dynacont (double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, ITG *nactdof, ITG *neq, ITG *nzl, ITG *icol, ITG *irow, ITG *nmethod, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *cocon, ITG *ncocon, double *alcon, ITG *nalcon, double *alzero, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, ITG *ithermal, double *prestr, ITG *iprestr, double *vold, ITG *iperturb, double *sti, ITG *nzs, double *tinc, double *tper, double *xmodal, double *veold, char *amname, double *amta, ITG *namta, ITG *nam, ITG *iamforc, ITG *iamload, ITG *iamt1, ITG *jout, char *filab, double *eme, double *xforcold, double *xloadold, double *t1old, ITG *iamboun, double *xbounold, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstate, ITG *npmat_, char *matname, ITG *mi, ITG *ncmat_, ITG *nstate_, double *ener, char *jobnamec, double *ttime, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nprint, char *prlab, char *prset, ITG *nener, double *trab, ITG *inotr, ITG *ntrans, double *fmpc, char *cbody, ITG *ibody, double *xbody, ITG *nbody, double *xbodyold, ITG *istep, ITG *isolver, ITG *jq, char *output, ITG *mcs, ITG *nkon, ITG *mpcend, ITG *ics, double *cs, ITG *ntie, char *tieset, ITG *idrct, ITG *jmax, double *tmin, double *tmax, double *ctrl, ITG *itpamp, double *tietol, ITG *iit, ITG *ncont, ITG *ne0, double *reltime, double *dtime, double *bcontini, double *bj, double *aux, ITG *iaux, double *bcont, ITG *nev, double *v, ITG *nkon0, double *deltmx, double *dtheta, double *theta, ITG *iprescribedboundary, ITG *mpcfree, ITG *memmpc_, ITG *itietri, ITG *koncont, double *cg, double *straight, ITG *iinc, double *vini, double *aa, double *bb, double *aanew, double *d, double *z, double *zeta, double *b, double *time0, double *time1, ITG *ipobody, double *xforcact, double *xloadact, double *t1act, double *xbounact, double *xbodyact, double *cd, double *cv, double *ampli, double *dthetaref, double *bjp, double *bp, double *cstr, ITG *imddof, ITG *nmddof, ITG **ikactcontp, ITG *nactcont, ITG *nactcont_, double *aamech, double *bprev, ITG *iprev, ITG *inonlinmpc, ITG **ikactmechp, ITG *nactmech, ITG *imdnode, ITG *nmdnode, ITG *imdboun, ITG *nmdboun, ITG *imdmpc, ITG *nmdmpc, ITG *itp, ITG *inext, ITG *imastop, ITG *nslavnode, ITG *islavnode, ITG *islavsurf, ITG *itiefac, double *areaslav, ITG *iponoels, ITG *inoels, double *springarea, ITG *izdof, ITG *nzdof, double *fn, ITG *imastnode, ITG *nmastnode, double *xmastnor, double *xstateini, ITG *nslavs, ITG *cyclicsymmetry, double *xnoels, ITG *ielas, ITG *ielprop, double *prop)
 
void dynboun (double *amta, ITG *namta, ITG *nam, double *ampli, double *time, double *ttime, double *dtime, double *xbounold, double *xboun, double *xbounact, ITG *iamboun, ITG *nboun, ITG *nodeboun, ITG *ndirboun, double *ad, double *au, double *adb, double *aub, ITG *icol, ITG *irow, ITG *neq, ITG *nzs, double *sigma, double *b, ITG *isolver, double *alpham, double *betam, ITG *nzl, ITG *init, double *bact, double *bmin, ITG *jq, char *amname, double *bv, double *bprev, double *bdiff, ITG *nactmech, ITG *icorrect, ITG *iprev)
 
void FORTRAN (dynresults,(ITG *nk, double *v, ITG *ithermal, ITG *nactdof, double *vold, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *nmpc, double *b, double *bp, double *veold, double *dtime, ITG *mi, ITG *imdnode, ITG *nmdnode, ITG *imdboun, ITG *nmdboun, ITG *imdmpc, ITG *nmdmpc, ITG *nmethod, double *time))
 
void FORTRAN (effectivemodalmass,(ITG *neq, ITG *nactdof, ITG *mi, double *adb, double *aub, ITG *jq, ITG *irow, ITG *nev, double *z, double *co, ITG *nk))
 
void electromagnetics (double **co, ITG *nk, ITG **konp, ITG **ipkonp, char **lakonp, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG **ipompcp, ITG **nodempcp, double **coefmpcp, char **labmpcp, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG **nelemloadp, char **sideloadp, double *xload, ITG *nload, ITG *nactdof, ITG **icolp, ITG *jq, ITG **irowp, ITG *neq, ITG *nzl, ITG *nmethod, ITG **ikmpcp, ITG **ilmpcp, ITG *ikboun, ITG *ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG **ielmatp, ITG **ielorienp, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, double *t1old, ITG *ithermal, double *prestr, ITG *iprestr, double **vold, ITG *iperturb, double *sti, ITG *nzs, ITG *kode, char *filab, ITG *idrct, ITG *jmax, ITG *jout, double *timepar, double *eme, double *xbounold, double *xforcold, double *xloadold, double *veold, double *accold, char *amname, double *amta, ITG *namta, ITG *nam, ITG *iamforc, ITG **iamloadp, ITG *iamt1, double *alpha, ITG *iexpl, ITG *iamboun, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double **xstatep, ITG *npmat_, ITG *istep, double *ttime, char *matname, double *qaold, ITG *mi, ITG *isolver, ITG *ncmat_, ITG *nstate_, ITG *iumat, double *cs, ITG *mcs, ITG *nkon, double **ener, ITG *mpcinfo, char *output, double *shcon, ITG *nshcon, double *cocon, ITG *ncocon, double *physcon, ITG *nflow, double *ctrl, char **setp, ITG *nset, ITG **istartsetp, ITG **iendsetp, ITG **ialsetp, ITG *nprint, char *prlab, char *prset, ITG *nener, ITG *ikforc, ITG *ilforc, double *trab, ITG *inotr, ITG *ntrans, double **fmpcp, char *cbody, ITG *ibody, double *xbody, ITG *nbody, double *xbodyold, ITG *ielprop, double *prop, ITG *ntie, char **tiesetp, ITG *itpamp, ITG *iviewfile, char *jobnamec, double **tietolp, ITG *nslavs, double *thicke, ITG *ics, ITG *nalset, ITG *nmpc_, ITG *nmat, char *typeboun, ITG *iaxial, ITG **idefloadp, ITG *nload_)
 
void FORTRAN (elementpernode,(ITG *iponoel, ITG *inoel, char *lakon, ITG *ipkon, ITG *kon, ITG *ne))
 
void FORTRAN (envtemp,(ITG *itg, ITG *ieg, ITG *ntg, ITG *ntr, char *sideload, ITG *nelemload, ITG *ipkon, ITG *kon, char *lakon, ITG *ielmat, ITG *ne, ITG *nload, ITG *kontri, ITG *ntri, ITG *nloadtr, ITG *nflow, ITG *ndirboun, ITG *nactdog, ITG *nodeboun, ITG *nacteq, ITG *nboun, ITG *ielprop, double *prop, ITG *nteq, double *v, ITG *network, double *physcon, double *shcon, ITG *ntmat_, double *co, double *vold, char *set, ITG *nshcon, double *rhcon, ITG *nrhcon, ITG *mi, ITG *nmpc, ITG *nodempc, ITG *ipompc, char *labmpc, ITG *ikboun, ITG *nasym, ITG *iaxial))
 
void FORTRAN (equationcheck,(double *ac, ITG *nteq, ITG *nactdog, ITG *itg, ITG *ntg, ITG *nacteq, ITG *network))
 
void FORTRAN (errorestimator,(double *yi, double *yn, ITG *ipkon, ITG *inum, ITG *kon, char *lakon, ITG *nk, ITG *ne, ITG *mi, ITG *ielmat, double *thicke, ITG *nterms))
 
void expand (double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, ITG *nactdof, ITG *neq, ITG *nmethod, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, ITG *ithermal, double *prestr, ITG *iprestr, double *vold, ITG *iperturb, double *sti, ITG *nzs, double *adb, double *aub, char *filab, double *eme, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstate, ITG *npmat_, char *matname, ITG *mi, ITG *ics, double *cs, ITG *mpcend, ITG *ncmat_, ITG *nstate_, ITG *mcs, ITG *nkon, double *ener, char *jobnamec, char *output, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nprint, char *prlab, char *prset, ITG *nener, double *trab, ITG *inotr, ITG *ntrans, double *ttime, double *fmpc, ITG *nev, double **z, ITG *iamboun, double *xbounold, ITG *nsectors, ITG *nm, ITG *icol, ITG *irow, ITG *nzl, ITG *nam, ITG *ipompcold, ITG *nodempcold, double *coefmpcold, char *labmpcold, ITG *nmpcold, double *xloadold, ITG *iamload, double *t1old, double *t1, ITG *iamt1, double *xstiff, ITG **icolep, ITG **jqep, ITG **irowep, ITG *isolver, ITG *nzse, double **adbep, double **aubep, ITG *iexpl, ITG *ibody, double *xbody, ITG *nbody, double *cocon, ITG *ncocon, char *tieset, ITG *ntie, ITG *imddof, ITG *nmddof, ITG *imdnode, ITG *nmdnode, ITG *imdboun, ITG *nmdboun, ITG *imdmpc, ITG *nmdmpc, ITG **izdofp, ITG *nzdof, ITG *nherm, double *xmr, double *xmi, char *typeboun, ITG *ielprop, double *prop)
 
void FORTRAN (extrapolate,(double *sti, double *stn, ITG *ipkon, ITG *inum, ITG *kon, char *lakon, ITG *nfield, ITG *nk, ITG *ne, ITG *mi, ITG *ndim, double *orab, ITG *ielorien, double *co, ITG *iorienglob, char *cflag, ITG *nelemload, ITG *nload, ITG *nodeboun, ITG *nboun, ITG *ndirboun, double *vold, ITG *ithermal, ITG *force, ITG *cfd, ITG *ielmat, double *thicke, char *filab))
 
void FORTRAN (extrapolate_ad_h,(ITG *nface, ITG *ielfa, double *xrlfa, double *ad, double *adfa, double *hel, double *hfa))
 
void FORTRAN (extrapolatefluid,(ITG *nk, ITG *iponofa, ITG *inofa, ITG *inum, double *vfa, double *v, ITG *ielfa, ITG *ithermal))
 
void FORTRAN (extrapolate_gradtel,(ITG *nface, ITG *ielfa, double *xrlfa, double *gradvel, double *gradvfa))
 
void FORTRAN (extrapolate_gradvel,(ITG *nface, ITG *ielfa, double *xrlfa, double *gradv, double *gradvfa))
 
void FORTRAN (extrapolate_pel,(ITG *nface, ITG *ielfa, double *xrlfa, double *vel, double *vfa, ITG *ifabou, double *xboun, ITG *nef))
 
void FORTRAN (extrapolate_tel,(ITG *nface, ITG *ielfa, double *xrlfa, double *vel, double *vfa, ITG *ifabou, double *xboun, ITG *ipnei, ITG *nef))
 
void FORTRAN (extrapolate_vel,(ITG *nface, ITG *ielfa, double *xrlfa, double *vel, double *vfa, ITG *ifabou, double *xboun, ITG *ipnei, ITG *nef))
 
void FORTRAN (fcrit,(double *time, double *tend, double *aai, double *bbi, double *zetaj, double *dj, double *ddj, double *h1, double *h2, double *h3, double *h4, double *func, double *funcp))
 
void FORTRAN (findsurface,(ITG *ipoface, ITG *nodface, ITG *ne, ITG *ipkon, ITG *kon, char *lakon, ITG *ntie, char *tieset))
 
void FORTRAN (flowoutput,(ITG *itg, ITG *ieg, ITG *ntg, ITG *nteq, double *bc, char *lakon, ITG *ntmat_, double *v, double *shcon, ITG *nshcon, ITG *ipkon, ITG *kon, double *co, ITG *nflow, double *dtime, double *ttime, double *time, ITG *ielmat, double *prop, ITG *ielprop, ITG *nactdog, ITG *nacteq, ITG *iin, double *physcon, double *camt, double *camf, double *camp, double *uamt, double *uamf, double *uamp, double *rhcon, ITG *nrhcon, double *vold, char *jobnamef, char *set, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nset, ITG *mi))
 
void FORTRAN (flowresult,(ITG *ntg, ITG *itg, double *cam, double *vold, double *v, ITG *nload, char *sideload, ITG *nelemload, double *xloadact, ITG *nactdog, ITG *network, ITG *mi, ITG *ne, ITG *ipkon, char *lakon, ITG *kon))
 
void FORTRAN (forcesolve,(double *zc, ITG *nev, double *aa, double *bb, double *xx, double *eiga, double *eigb, double *eigxx, ITG *iter, double *d, ITG *neq, double *z, ITG *istartnmd, ITG *iendnmd, ITG *nmd, ITG *cyclicsymmetry, ITG *neqact, ITG *igeneralizedforce))
 
void frd (double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne0, double *v, double *stn, ITG *inum, ITG *nmethod, ITG *kode, char *filab, double *een, double *t1, double *fn, double *time, double *epn, ITG *ielmat, char *matname, double *enern, double *xstaten, ITG *nstate_, ITG *istep, ITG *iinc, ITG *ithermal, double *qfn, ITG *mode, ITG *noddiam, double *trab, ITG *inotr, ITG *ntrans, double *orab, ITG *ielorien, ITG *norien, char *description, ITG *ipneigh, ITG *neigh, ITG *mi, double *stx, double *vr, double *vi, double *stnr, double *stni, double *vmax, double *stnmax, ITG *ngraph, double *veold, double *ener, ITG *ne, double *cs, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, double *eenmax, double *fnr, double *fni, double *emn, double *thicke, char *jobnamec, char *output, double *qfx, double *cdn, ITG *mortar, double *cdnr, double *cdni, ITG *nmat)
 
void frdcyc (double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, double *v, double *stn, ITG *inum, ITG *nmethod, ITG *kode, char *filab, double *een, double *t1, double *fn, double *time, double *epn, ITG *ielmat, char *matname, double *cs, ITG *mcs, ITG *nkon, double *enern, double *xstaten, ITG *nstate_, ITG *istep, ITG *iinc, ITG *iperturb, double *ener, ITG *mi, char *output, ITG *ithermal, double *qfn, ITG *ialset, ITG *istartset, ITG *iendset, double *trab, ITG *inotr, ITG *ntrans, double *orab, ITG *ielorien, ITG *norien, double *sti, double *veold, ITG *noddiam, char *set, ITG *nset, double *emn, double *thicke, char *jobnamec, ITG *ne0, double *cdn, ITG *mortar, ITG *nmat)
 
void FORTRAN (frdfluid,(double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, double *v, ITG *kode, double *time, ITG *ielmat, char *matname, char *filab, ITG *inum, ITG *ntrans, ITG *inotr, double *trab, ITG *mi, ITG *istep, double *stn, double *qfn, ITG *nactdofinv))
 
void frdheader (ITG *icounter, double *oner, double *time, double *pi, ITG *noddiam, double *cs, ITG *null, ITG *mode, ITG *noutloc, char *description, ITG *kode, ITG *nmethod, FILE *f1, char *output, ITG *istep, ITG *iinc)
 
void FORTRAN (frditeration,(double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, double *v, double *time, ITG *ielmat, char *matname, ITG *mi, ITG *istep, ITG *iinc, ITG *ithermal))
 
void frdselect (double *field1, double *field2, ITG *iset, ITG *nkcoords, ITG *inum, char *m1, ITG *istartset, ITG *iendset, ITG *ialset, ITG *ngraph, ITG *ncomp, ITG *ifield, ITG *icomp, ITG *nfield, ITG *iselect, char *m2, FILE *f1, char *output, char *m3)
 
void frdset (char *filabl, char *set, ITG *iset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *inum, ITG *noutloc, ITG *nout, ITG *nset, ITG *noutmin, ITG *noutplus, ITG *iselect, ITG *ngraph)
 
void frdvector (double *v, ITG *iset, ITG *ntrans, char *filabl, ITG *nkcoords, ITG *inum, char *m1, ITG *inotr, double *trab, double *co, ITG *istartset, ITG *iendset, ITG *ialset, ITG *mi, ITG *ngraph, FILE *f1, char *output, char *m3)
 
void FORTRAN (fsub,(double *time, double *tend, double *aai, double *bbi, double *ddj, double *h1, double *h2, double *h3, double *h4, double *func, double *funcp))
 
void FORTRAN (fsuper,(double *time, double *tend, double *aai, double *bbi, double *h1, double *h2, double *h3, double *h4, double *h5, double *h6, double *func, double *funcp))
 
void FORTRAN (gasmechbc,(double *vold, ITG *nload, char *sideload, ITG *nelemload, double *xload, ITG *mi))
 
void FORTRAN (genadvecelem,(ITG *inodesd, ITG *ipkon, ITG *ne, char *lakon, ITG *kon, ITG *nload, char *sideload, ITG *nelemload, ITG *nkon))
 
void FORTRAN (gencontelem_f2f,(char *tieset, ITG *ntie, ITG *itietri, ITG *ne, ITG *ipkon, ITG *kon, char *lakon, double *cg, double *straight, ITG *ifree, ITG *koncont, double *co, double *vold, double *xo, double *yo, double *zo, double *x, double *y, double *z, ITG *nx, ITG *ny, ITG *nz, ITG *ielmat, double *elcon, ITG *istep, ITG *iinc, ITG *iit, ITG *ncmat_, ITG *ntmat_, ITG *mi, ITG *imastop, ITG *islavsurf, ITG *itiefac, double *springarea, double *tietol, double *reltime, char *filab, ITG *nasym, double *pslavsurf, double *pmastsurf, double *clearini, double *theta))
 
void FORTRAN (gencontelem_n2f,(char *tieset, ITG *ntie, ITG *itietri, ITG *ne, ITG *ipkon, ITG *kon, char *lakon, double *cg, double *straight, ITG *ifree, ITG *koncont, double *co, double *vold, double *xo, double *yo, double *zo, double *x, double *y, double *z, ITG *nx, ITG *ny, ITG *nz, ITG *ielmat, double *elcon, ITG *istep, ITG *iinc, ITG *iit, ITG *ncmat_, ITG *ntmat_, ITG *nmethod, ITG *mi, ITG *imastop, ITG *nslavnode, ITG *islavnode, ITG *islavsurf, ITG *itiefac, double *areaslav, ITG *iponoels, ITG *inoels, double *springarea, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, double *tietol, double *reltime, ITG *imastnode, ITG *nmastnode, char *filab, ITG *nasym, double *xnoels))
 
void FORTRAN (generateeminterfaces,(ITG *istartset, ITG *iendset, ITG *ialset, ITG *iactive, ITG *ipkon, char *lakon, ITG *kon, ITG *ikmpc, ITG *nmpc, ITG *nafaces))
 
void FORTRAN (generatetet,(ITG *kontet, ITG *ifatet, ITG *netet, ITG *inodfa, ITG *ifreefa, double *planfa, ITG *ipofa, ITG *nodes, double *cotet))
 
void FORTRAN (gennactdofinv,(ITG *nactdof, ITG *nactdofinv, ITG *nk, ITG *mi, ITG *nodorig, ITG *ipkon, char *lakon, ITG *kon, ITG *ne))
 
void FORTRAN (gentiedmpc,(char *tieset, ITG *ntie, ITG *itietri, ITG *ipkon, ITG *kon, char *lakon, char *set, ITG *istartset, ITG *iendset, ITG *ialset, double *cg, double *straight, ITG *koncont, double *co, double *xo, double *yo, double *zo, double *x, double *y, double *z, ITG *nx, ITG *ny, ITG *nz, ITG *nset, ITG *ifaceslave, ITG *istartfield, ITG *iendfield, ITG *ifield, ITG *ipompc, ITG *nodempc, double *coefmpc, ITG *nmpc, ITG *nmpc_, ITG *mpcfree, ITG *ikmpc, ITG *ilmpc, char *labmpc, ITG *ithermal, double *tietol, ITG *icfd, ITG *ncont, ITG *imastop, ITG *ikboun, ITG *nboun, char *kind))
 
void FORTRAN (geomview,(double *vold, double *co, double *pmid, double *e1, double *e2, double *e3, ITG *kontri, double *area, double *cs, ITG *mcs, ITG *inocs, ITG *ntrit, ITG *nk, ITG *mi, double *sidemean))
 
void getglobalresults (char *jobnamec, ITG **integerglobp, double **doubleglobp, ITG *nboun, ITG *iamboun, double *xboun, ITG *nload, char *sideload, ITG *iamload, ITG *iglob, ITG *nforc, ITG *iamforc, double *xforc, ITG *ithermal, ITG *nk, double *t1, ITG *iamt1)
 
ITG getSystemCPUs ()
 
void FORTRAN (identamta,(double *amta, double *reftime, ITG *istart, ITG *iend, ITG *id))
 
void FORTRAN (identifytiedface,(char *tieset, ITG *ntie, char *set, ITG *nset, ITG *faceslave, char *kind))
 
void FORTRAN (includefilename,(char *buff, char *includefn, ITG *lincludefn))
 
void FORTRAN (inicalcbody,(ITG *nef, double *body, ITG *ipobody, ITG *ibody, double *xbody, double *coel, double *vel, char *lakon, ITG *nactdohinv, ITG *icent))
 
void inicont (ITG *nk, ITG *ncont, ITG *ntie, char *tieset, ITG *nset, char *set, ITG *istartset, ITG *iendset, ITG *ialset, ITG **itietrip, char *lakon, ITG *ipkon, ITG *kon, ITG **koncontp, ITG *ncone, double *tietol, ITG *ismallsliding, ITG **itiefacp, ITG **islavsurfp, ITG **islavnodep, ITG **imastnodep, ITG **nslavnodep, ITG **nmastnodep, ITG *mortar, ITG **imastopp, ITG *nkon, ITG **iponoels, ITG **inoelsp, ITG **ipep, ITG **imep, ITG *ne, ITG *ifacecount, ITG *nmpc, ITG *mpcfree, ITG *memmpc_, ITG **ipompcp, char **labmpcp, ITG **ikmpcp, ITG **ilmpcp, double **fmpcp, ITG **nodempcp, double **coefmpcp, ITG *iperturb, ITG *ikboun, ITG *nboun, double *co, ITG *istep, double **xnoelsp)
 
void FORTRAN (init,(ITG *nktet, ITG *inodfa, ITG *ipofa, ITG *netet_))
 
void FORTRAN (initialcfd,(ITG *ne, ITG *ipkon, ITG *kon, char *lakon, double *co, double *coel, double *cofa, ITG *nface, ITG *ielfa, double *area, ITG *ipnei, ITG *neiel, double *xxn, double *xxi, double *xle, double *xlen, double *xlet, double *xrlfa, double *cosa, double *volume, ITG *neifa, double *xxj, double *cosb, double *vel, double *dmin))
 
void FORTRAN (initialchannel,(ITG *itg, ITG *ieg, ITG *ntg, double *ac, double *bc, char *lakon, double *v, ITG *ipkon, ITG *kon, ITG *nflow, ITG *ikboun, ITG *nboun, double *prop, ITG *ielprop, ITG *nactdog, ITG *ndirboun, ITG *nodeboun, double *xbounact, ITG *ielmat, ITG *ntmat_, double *shcon, ITG *nshcon, double *physcon, ITG *ipiv, ITG *nteq, double *rhcon, ITG *nrhcon, ITG *ipobody, ITG *ibody, double *xbody, double *co, ITG *nbody, ITG *network, ITG *iin_abs, double *vold, char *set, ITG *istep, ITG *iit, ITG *mi, ITG *ineighe, ITG *ilboun))
 
void FORTRAN (initialnet,(ITG *itg, ITG *ieg, ITG *ntg, double *ac, double *bc, char *lakon, double *v, ITG *ipkon, ITG *kon, ITG *nflow, ITG *ikboun, ITG *nboun, double *prop, ITG *ielprop, ITG *nactdog, ITG *ndirboun, ITG *nodeboun, double *xbounact, ITG *ielmat, ITG *ntmat_, double *shcon, ITG *nshcon, double *physcon, ITG *ipiv, ITG *nteq, double *rhcon, ITG *nrhcon, ITG *ipobody, ITG *ibody, double *xbody, double *co, ITG *nbody, ITG *network, ITG *iin_abs, double *vold, char *set, ITG *istep, ITG *iit, ITG *mi, ITG *ineighe, ITG *ilboun, ITG *channel, ITG *iaxial))
 
void insert (ITG *ipointer, ITG **mast1p, ITG **mast2p, ITG *i1, ITG *i2, ITG *ifree, ITG *nzs_)
 
void insertrad (ITG *ipointer, ITG **mast1p, ITG **mast2p, ITG *i1, ITG *i2, ITG *ifree, ITG *nzs_)
 
void FORTRAN (integral_boundary,(double *sumfix, double *sumfree, ITG *ifaext, ITG *nfaext, ITG *ielfa, ITG *ifabou, double *vfa, ITG *ipnei, double *xxn))
 
void FORTRAN (interpolatestate,(ITG *ne, ITG *ipkon, ITG *kon, char *lakon, ITG *ne0, ITG *mi, double *xstate, double *pslavsurf, ITG *nstate_, double *xstateini, ITG *islavsurf, ITG *islavsurfold, double *pslavsurfold))
 
void FORTRAN (islavactive,(char *tieset, ITG *ntie, ITG *itietri, double *cg, double *straight, double *co, double *vold, double *xo, double *yo, double *zo, double *x, double *y, double *z, ITG *nx, ITG *ny, ITG *nz, ITG *mi, ITG *imastop, ITG *nslavnode, ITG *islavnode, ITG *islavact))
 
void FORTRAN (isortid,(ITG *ix, double *dy, ITG *n, ITG *kflag))
 
void FORTRAN (isortii,(ITG *ix, ITG *iy, ITG *n, ITG *kflag))
 
void FORTRAN (isortiid,(ITG *ix, ITG *iy, double *dy, ITG *n, ITG *kflag))
 
void FORTRAN (isortiddc,(ITG *ix, double *dy1, double *dy2, char *cy, ITG *n, ITG *kflag))
 
void FORTRAN (isortiiddc,(ITG *ix1, ITG *ix2, double *dy1, double *dy2, char *cy, ITG *n, ITG *kflag))
 
void FORTRAN (jouleheating,(ITG *ipkon, char *lakon, ITG *kon, double *co, double *elcon, ITG *nelcon, ITG *mi, ITG *ne, double *sti, ITG *ielmat, ITG *nelemload, char *sideload, double *xload, ITG *nload, ITG *nload_, ITG *iamload, ITG *nam, ITG *idefload, ITG *ncmat_, ITG *ntmat_, double *alcon, ITG *nalcon, ITG *ithermal, double *vold, double *t1))
 
void FORTRAN (keystart,(ITG *ifreeinp, ITG *ipoinp, ITG *inp, char *name, ITG *iline, ITG *ikey))
 
void linstatic (double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, ITG *nactdof, ITG **icolp, ITG *jq, ITG **irowp, ITG *neq, ITG *nzl, ITG *nmethod, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, double *t1old, ITG *ithermal, double *prestr, ITG *iprestr, double *vold, ITG *iperturb, double *sti, ITG *nzs, ITG *kode, char *filab, double *eme, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstate, ITG *npmat_, char *matname, ITG *isolver, ITG *mi, ITG *ncmat_, ITG *nstate_, double *cs, ITG *mcs, ITG *nkon, double *ener, double *xbounold, double *xforcold, double *xloadold, char *amname, double *amta, ITG *namta, ITG *nam, ITG *iamforc, ITG *iamload, ITG *iamt1, ITG *iamboun, double *ttime, char *output, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nprint, char *prlab, char *prset, ITG *nener, double *trab, ITG *inotr, ITG *ntrans, double *fmpc, char *cbody, ITG *ibody, double *xbody, ITG *nbody, double *xbodyold, double *timepar, double *thicke, char *jobnamec, char *tieset, ITG *ntie, ITG *istep, ITG *nmat, ITG *ielprop, double *prop, char *typeboun)
 
void FORTRAN (mafillcorio,(double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, double *xbody, ITG *ipobody, ITG *nbody, double *cgr, double *ad, double *au, ITG *nactdof, ITG *icol, ITG *jq, ITG *irow, ITG *neq, ITG *nzl, ITG *nmethod, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, ITG *ithermal, double *prestr, ITG *iprestr, double *vold, ITG *iperturb, double *sti, ITG *nzs, double *stx, double *adb, double *aub, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstiff, ITG *npmat_, double *dtime, char *matname, ITG *mi, ITG *ncmat_, double *ttime, double *time, ITG *istep, ITG *kinc, ITG *ibody))
 
void FORTRAN (mafilldm,(double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, double *xbody, ITG *ipobody, ITG *nbody, double *cgr, double *ad, double *au, ITG *nactdof, ITG *icol, ITG *jq, ITG *irow, ITG *neq, ITG *nzl, ITG *nmethod, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, ITG *ithermal, double *prestr, ITG *iprestr, double *vold, ITG *iperturb, double *sti, ITG *nzs, double *stx, double *adb, double *aub, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstiff, ITG *npmat_, double *dtime, char *matname, ITG *mi, ITG *ncmat_, double *ttime, double *time, ITG *istep, ITG *kinc, ITG *ibody, double *clearini, ITG *mortar, double *springarea, double *pslavsurf, double *pmastsurf, double *reltime, ITG *nasym))
 
void FORTRAN (mafillem,(double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, double *xbody, ITG *ipobody, ITG *nbody, double *cgr, double *ad, double *au, double *bb, ITG *nactdof, ITG *icol, ITG *jq, ITG *irow, ITG *neq, ITG *nzl, ITG *nmethod, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, ITG *ithermal, double *prestr, ITG *iprestr, double *vold, ITG *iperturb, double *sti, ITG *nzs, double *stx, double *adb, double *aub, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstiff, ITG *npmat_, double *dtime, char *matname, ITG *mi, ITG *ncmat_, ITG *mass, ITG *stiffness, ITG *buckling, ITG *rhs, ITG *intscheme, double *physcon, double *shcon, ITG *nshcon, double *cocon, ITG *ncocon, double *ttime, double *time, ITG *istep, ITG *kinc, ITG *coriolis, ITG *ibody, double *xloadold, double *reltime, double *veold, double *springarea, ITG *nstate_, double *xstateini, double *xstate, double *thicke, ITG *integerglob, double *doubleglob, char *tieset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *ntie, ITG *nasym, ITG *iactive, double *h0, double *pslavsurf, double *pmastsurf, ITG *mortar, double *clearini, ITG *ielprop, double *prop))
 
void FORTRAN (mafillnet,(ITG *itg, ITG *ieg, ITG *ntg, double *ac, ITG *nload, char *sideload, ITG *nelemload, double *xloadact, char *lakon, ITG *ntmat_, double *v, double *shcon, ITG *nshcon, ITG *ipkon, ITG *kon, double *co, ITG *nflow, ITG *iinc, ITG *istep, double *dtime, double *ttime, double *time, ITG *ielmat, ITG *nteq, double *prop, ITG *ielprop, ITG *nactdog, ITG *nacteq, double *physcon, double *rhcon, ITG *nrhcon, ITG *ipobody, ITG *ibody, double *xbody, ITG *nbody, double *vold, double *xloadold, double *reltime, ITG *nmethod, char *set, ITG *mi, ITG *nmpc, ITG *nodempc, ITG *ipompc, double *coefmpc, char *labmpc, ITG *iaxial))
 
void FORTRAN (mafillp,(ITG *ne, char *lakon, ITG *ipnei, ITG *neifa, ITG *neiel, double *vfa, double *area, double *adfa, double *xlet, double *cosa, double *volume, double *au, double *ad, ITG *jq, ITG *irow, double *ap, ITG *ielfa, ITG *ifabou, double *xle, double *b, double *xxn, ITG *compressible, ITG *neq, ITG *nzs, double *hfa, double *gradpel, double *bp, double *xxi, ITG *neij, double *xlen, double *cosb))
 
void FORTRAN (mafillsm,(double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, double *xbody, ITG *ipobody, ITG *nbody, double *cgr, double *ad, double *au, double *bb, ITG *nactdof, ITG *icol, ITG *jq, ITG *irow, ITG *neq, ITG *nzl, ITG *nmethod, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, ITG *ithermal, double *prestr, ITG *iprestr, double *vold, ITG *iperturb, double *sti, ITG *nzs, double *stx, double *adb, double *aub, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstiff, ITG *npmat_, double *dtime, char *matname, ITG *mi, ITG *ncmat_, ITG *mass, ITG *stiffness, ITG *buckling, ITG *rhs, ITG *intscheme, double *physcon, double *shcon, ITG *nshcon, double *cocon, ITG *ncocon, double *ttime, double *time, ITG *istep, ITG *kinc, ITG *coriolis, ITG *ibody, double *xloadold, double *reltime, double *veold, double *springarea, ITG *nstate_, double *xstateini, double *xstate, double *thicke, ITG *integerglob, double *doubleglob, char *tieset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *ntie, ITG *nasym, double *pslavsurf, double *pmastsurf, ITG *mortar, double *clearini, ITG *ielprop, double *prop))
 
void FORTRAN (mafillsmas,(double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, double *xbody, ITG *ipobody, ITG *nbody, double *cgr, double *ad, double *au, double *bb, ITG *nactdof, ITG *icol, ITG *jq, ITG *irow, ITG *neq, ITG *nzl, ITG *nmethod, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, ITG *ithermal, double *prestr, ITG *iprestr, double *vold, ITG *iperturb, double *sti, ITG *nzs, double *stx, double *adb, double *aub, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstiff, ITG *npmat_, double *dtime, char *matname, ITG *mi, ITG *ncmat_, ITG *mass, ITG *stiffness, ITG *buckling, ITG *rhs, ITG *intscheme, double *physcon, double *shcon, ITG *nshcon, double *cocon, ITG *ncocon, double *ttime, double *time, ITG *istep, ITG *kinc, ITG *coriolis, ITG *ibody, double *xloadold, double *reltime, double *veold, double *springarea, ITG *nstate_, double *xstateini, double *xstate, double *thicke, ITG *integerglob, double *doubleglob, char *tieset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *ntie, ITG *nasym, double *pslavsurf, double *pmastsurf, ITG *mortar, double *clearini, ITG *ielprop, double *prop))
 
void FORTRAN (mafillsmcs,(double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, double *xbody, ITG *ipobody, ITG *nbody, double *cgr, double *ad, double *au, double *bb, ITG *nactdof, ITG *icol, ITG *jq, ITG *irow, ITG *neq, ITG *nzl, ITG *nmethod, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, ITG *ithermal, double *prestr, ITG *iprestr, double *vold, ITG *iperturb, double *sti, ITG *nzs, double *stx, double *adb, double *aub, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstiff, ITG *npmat_, double *dtime, char *matname, ITG *mi, ITG *ics, double *cs, ITG *nm, ITG *ncmat_, char *labmpc, ITG *mass, ITG *stiffness, ITG *buckling, ITG *rhs, ITG *intscheme, ITG *mcs, ITG *coriolis, ITG *ibody, double *xloadold, double *reltime, ITG *ielcs, double *veold, double *springarea, double *thicke, ITG *integerglob, double *doubleglob, char *tieset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *ntie, ITG *nasym, double *pslavsurf, double *pmastsurf, ITG *mortar, double *clearini, ITG *ielprop, double *prop))
 
void FORTRAN (mafillsmcsas,(double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, double *xbody, ITG *ipobody, ITG *nbody, double *cgr, double *ad, double *au, double *bb, ITG *nactdof, ITG *icol, ITG *jq, ITG *irow, ITG *neq, ITG *nzl, ITG *nmethod, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, ITG *ithermal, double *prestr, ITG *iprestr, double *vold, ITG *iperturb, double *sti, ITG *nzs, double *stx, double *adb, double *aub, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstiff, ITG *npmat_, double *dtime, char *matname, ITG *mi, ITG *ics, double *cs, ITG *nm, ITG *ncmat_, char *labmpc, ITG *mass, ITG *stiffness, ITG *buckling, ITG *rhs, ITG *intscheme, ITG *mcs, ITG *coriolis, ITG *ibody, double *xloadold, double *reltime, ITG *ielcs, double *veold, double *springarea, double *thicke, ITG *integerglob, double *doubleglob, char *tieset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *ntie, ITG *nasym, ITG *nstate_, double *xstateini, double *xstate, double *pslavsurf, double *pmastsurf, ITG *mortar, double *clearini, ITG *ielprop, double *prop))
 
void FORTRAN (mafillt,(ITG *nef, ITG *ipnei, ITG *neifa, ITG *neiel, double *vfa, double *xxn, double *area, double *au, double *ad, ITG *jq, ITG *irow, ITG *nzs, double *b, double *vel, double *umel, double *xlet, double *xle, double *gradtfa, double *xxi, double *body, double *volume, ITG *compressible, ITG *ielfa, char *lakon, ITG *ifabou, ITG *nbody, ITG *neq, double *dtimef, double *velo, double *veloo, double *cpfa, double *hcfa, double *cpel, double *gradvel, double *xload, double *gammat, double *xrlfa, double *xxj, ITG *nactdohinv, double *a1, double *a2, double *a3))
 
void FORTRAN (mafillv,(ITG *nef, ITG *ipnei, ITG *neifa, ITG *neiel, double *vfa, double *xxn, double *area, double *au, double *ad, ITG *jq, ITG *irow, ITG *nzs, double *b, double *vel, double *cosa, double *umfa, double *xlet, double *xle, double *gradvfa, double *xxi, double *body, double *volume, ITG *compressible, ITG *ielfa, char *lakon, ITG *ifabou, ITG *nbody, ITG *neq, double *dtimef, double *velo, double *veloo, double *sel, double *xrlfa, double *gamma, double *xxj, ITG *nactdohinv, double *a1, double *a2, double *a3))
 
void mastruct (ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nodeboun, ITG *ndirboun, ITG *nboun, ITG *ipompc, ITG *nodempc, ITG *nmpc, ITG *nactdof, ITG *icol, ITG *jq, ITG **mast1p, ITG **irowp, ITG *isolver, ITG *neq, ITG *ikmpc, ITG *ilmpc, ITG *ipointer, ITG *nzs, ITG *nmethod, ITG *ithermal, ITG *ikboun, ITG *ilboun, ITG *iperturb, ITG *mi, ITG *mortar, char *typeboun, char *labmpc)
 
void mastructcs (ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nodeboun, ITG *ndirboun, ITG *nboun, ITG *ipompc, ITG *nodempc, ITG *nmpc, ITG *nactdof, ITG *icol, ITG *jq, ITG **mast1p, ITG **irowp, ITG *isolver, ITG *neq, ITG *ikmpc, ITG *ilmpc, ITG *ipointer, ITG *nzs, ITG *nmethod, ITG *ics, double *cs, char *labmpc, ITG *mcs, ITG *mi, ITG *mortar)
 
void mastructem (ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nodeboun, ITG *ndirboun, ITG *nboun, ITG *ipompc, ITG *nodempc, ITG *nmpc, ITG *nactdof, ITG *icol, ITG *jq, ITG **mast1p, ITG **irowp, ITG *isolver, ITG *neq, ITG *ikmpc, ITG *ilmpc, ITG *ipointer, ITG *nzs, ITG *ithermal, ITG *mi, ITG *ielmat, double *elcon, ITG *ncmat_, ITG *ntmat_, ITG *inomat)
 
void mastructf (ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *icol, ITG *jq, ITG **mast1p, ITG **irowp, ITG *isolver, ITG *neq, ITG *ipointer, ITG *nzs, ITG *ipnei, ITG *ineiel, ITG *mi)
 
void mastructrad (ITG *ntr, ITG *nloadtr, char *sideload, ITG *ipointerrad, ITG **mast1radp, ITG **irowradp, ITG *nzsrad, ITG *jqrad, ITG *icolrad)
 
void FORTRAN (meannode,(ITG *nk, ITG *inum, double *v))
 
void FORTRAN (mpcrem,(ITG *i, ITG *mpcfree, ITG *nodempc, ITG *nmpc, ITG *ikmpc, ITG *ilmpc, char *labmpc, double *coefmpc, ITG *ipompc))
 
void FORTRAN (mult,(double *matrix, double *trans, ITG *n))
 
void FORTRAN (negativepressure,(ITG *ne0, ITG *ne, ITG *mi, double *stx, double *pressureratio))
 
void FORTRAN (networkinum,(ITG *ipkon, ITG *inum, ITG *kon, char *lakon, ITG *ne, ITG *itg, ITG *ntg))
 
void FORTRAN (nident,(ITG *x, ITG *px, ITG *n, ITG *id))
 
void FORTRAN (nidentll,(long long *x, long long *px, ITG *n, ITG *id))
 
void FORTRAN (nodestiedface,(char *tieset, ITG *ntie, ITG *ipkon, ITG *kon, char *lakon, char *set, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nset, ITG *faceslave, ITG *istartfield, ITG *iendfield, ITG *ifield, ITG *nconf, ITG *ncone, char *kind))
 
void nonlingeo (double **co, ITG *nk, ITG **konp, ITG **ipkonp, char **lakonp, ITG *ne, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG **ipompcp, ITG **nodempcp, double **coefmpcp, char **labmpcp, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, ITG *nactdof, ITG **icolp, ITG *jq, ITG **irowp, ITG *neq, ITG *nzl, ITG *nmethod, ITG **ikmpcp, ITG **ilmpcp, ITG *ikboun, ITG *ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG **ielmatp, ITG **ielorienp, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, double *t1old, ITG *ithermal, double *prestr, ITG *iprestr, double **vold, ITG *iperturb, double *sti, ITG *nzs, ITG *kode, char *filab, ITG *idrct, ITG *jmax, ITG *jout, double *timepar, double *eme, double *xbounold, double *xforcold, double *xloadold, double *veold, double *accold, char *amname, double *amta, ITG *namta, ITG *nam, ITG *iamforc, ITG *iamload, ITG *iamt1, double *alpha, ITG *iexpl, ITG *iamboun, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double **xstatep, ITG *npmat_, ITG *istep, double *ttime, char *matname, double *qaold, ITG *mi, ITG *isolver, ITG *ncmat_, ITG *nstate_, ITG *iumat, double *cs, ITG *mcs, ITG *nkon, double **ener, ITG *mpcinfo, char *output, double *shcon, ITG *nshcon, double *cocon, ITG *ncocon, double *physcon, ITG *nflow, double *ctrl, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nprint, char *prlab, char *prset, ITG *nener, ITG *ikforc, ITG *ilforc, double *trab, ITG *inotr, ITG *ntrans, double **fmpcp, char *cbody, ITG *ibody, double *xbody, ITG *nbody, double *xbodyold, ITG *ielprop, double *prop, ITG *ntie, char *tieset, ITG *itpamp, ITG *iviewfile, char *jobnamec, double *tietol, ITG *nslavs, double *thicke, ITG *ics, ITG *nintpoint, ITG *mortar, ITG *ifacecount, char *typeboun, ITG **islavsurfp, double **pslavsurfp, double **clearinip, ITG *nmat, double *xmodal, ITG *iaxial, ITG *inext)
 
void FORTRAN (nonlinmpc,(double *co, double *vold, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *nmpc, ITG *ikboun, ITG *ilboun, ITG *nboun, double *xbounact, double *aux, ITG *iaux, ITG *maxlenmpc, ITG *ikmpc, ITG *ilmpc, ITG *icascade, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, double *reltime, ITG *newstep, double *xboun, double *fmpc, ITG *newinc, ITG *idiscon, ITG *ncont, double *trab, ITG *ntrans, ITG *ithermal, ITG *mi))
 
void FORTRAN (normalsoninterface,(ITG *istartset, ITG *iendset, ITG *ialset, ITG *imast, ITG *ipkon, ITG *kon, char *lakon, ITG *imastnode, ITG *nmastnode, double *xmastnor, double *co))
 
void FORTRAN (op,(ITG *n, double *x, double *y, double *ad, double *au, ITG *jq, ITG *irow))
 
void FORTRAN (opas,(ITG *n, double *x, double *y, double *ad, double *au, ITG *jq, ITG *irow, ITG *nzs))
 
void FORTRAN (op_corio,(ITG *n, double *x, double *y, double *ad, double *au, ITG *jq, ITG *irow))
 
void FORTRAN (openfile,(char *jobname, char *output))
 
void FORTRAN (openfilefluid,(char *jobname))
 
void FORTRAN (postview,(ITG *ntr, char *sideload, ITG *nelemload, ITG *kontri, ITG *ntri, ITG *nloadtr, double *tenv, double *adview, double *auview, double *area, double *fenv, ITG *jqrad, ITG *irowrad, ITG *nzsrad))
 
void FORTRAN (precfd,(ITG *ne, ITG *ipkon, ITG *kon, char *lakon, ITG *ipnei, ITG *neifa, ITG *neiel, ITG *ipoface, ITG *nodface, ITG *ielfa, ITG *nkonnei, ITG *nface, ITG *ifaext, ITG *nfaext, ITG *isolidsurf, ITG *nsolidsurf, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, double *vel, double *vold, ITG *mi, ITG *neij, ITG *nef, ITG *nactdoh, ITG *ipkonf, char *lakonf, ITG *ielmatf, ITG *ielmat, ITG *ielorienf, ITG *ielorien, ITG *norien))
 
void precontact (ITG *ncont, ITG *ntie, char *tieset, ITG *nset, char *set, ITG *istartset, ITG *iendset, ITG *ialset, ITG *itietri, char *lakon, ITG *ipkon, ITG *kon, ITG *koncont, ITG *ne, double *cg, double *straight, double *co, double *vold, ITG *istep, ITG *iinc, ITG *iit, ITG *itiefac, ITG *islavsurf, ITG *islavnode, ITG *imastnode, ITG *nslavnode, ITG *nmastnode, ITG *imastop, ITG *mi, ITG *ipe, ITG *ime, double *tietol, ITG *iflagact, ITG *nintpoint, double **pslavsurfp, double *xmastnor, double *cs, ITG *mcs, ITG *ics, double *clearini, ITG *nslavs)
 
void prediction (double *uam, ITG *nmethod, double *bet, double *gam, double *dtime, ITG *ithermal, ITG *nk, double *veold, double *accold, double *v, ITG *iinc, ITG *idiscon, double *vold, ITG *nactdof, ITG *mi)
 
void prediction_em (double *uam, ITG *nmethod, double *bet, double *gam, double *dtime, ITG *ithermal, ITG *nk, double *veold, double *v, ITG *iinc, ITG *idiscon, double *vold, ITG *nactdof, ITG *mi)
 
void preiter (double *ad, double **aup, double *b, ITG **icolp, ITG **irowp, ITG *neq, ITG *nzs, ITG *isolver, ITG *iperturb)
 
void FORTRAN (printout,(char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nprint, char *prlab, char *prset, double *v, double *t1, double *fn, ITG *ipkon, char *lakon, double *stx, double *eei, double *xstate, double *ener, ITG *mi, ITG *nstate_, ITG *ithermal, double *co, ITG *kon, double *qfx, double *ttime, double *trab, ITG *inotr, ITG *ntrans, double *orab, ITG *ielorien, ITG *norien, ITG *nk, ITG *ne, ITG *inum, char *filab, double *vold, ITG *ikin, ITG *ielmat, double *thicke, double *eme, ITG *islavsurf, ITG *mortar))
 
void FORTRAN (printoutfluid,(char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nprint, char *prlab, char *prset, double *v, double *t1, double *fn, ITG *ipkon, char *lakon, double *stx, double *eei, double *xstate, double *ener, ITG *mi, ITG *nstate_, ITG *ithermal, double *co, ITG *kon, double *qfx, double *ttime, double *trab, ITG *inotr, ITG *ntrans, double *orab, ITG *ielorien, ITG *norien, ITG *nk, ITG *ne, ITG *inum, char *filab, double *vold, ITG *ielmat, double *thicke, double *eme, double *vcontu, double *physcon, ITG *nactdoh, ITG *ielpropf, double *prop))
 
void FORTRAN (printoutface,(double *co, double *rhcon, ITG *nrhcon, ITG *ntmat_, double *vold, double *shcon, ITG *nshcon, double *cocon, ITG *ncocon, ITG *icompressible, ITG *istartset, ITG *iendset, ITG *ipkon, char *lakon, ITG *kon, ITG *ialset, char *prset, double *timef, ITG *nset, char *set, ITG *nprint, char *prlab, ITG *ielmat, ITG *mi))
 
int pthread_create (pthread_t *thread_id, const pthread_attr_t *attributes, void *(*thread_function)(void *), void *arguments)
 
int pthread_join (pthread_t thread, void **status_ptr)
 
void radcyc (ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, double *cs, ITG *mcs, ITG *nkon, ITG *ialset, ITG *istartset, ITG *iendset, ITG **kontrip, ITG *ntri, double **cop, double **voldp, ITG *ntrit, ITG *inocs, ITG *mi)
 
void radflowload (ITG *itg, ITG *ieg, ITG *ntg, ITG *ntr, double *adrad, double *aurad, double *bcr, ITG *ipivr, double *ac, double *bc, ITG *nload, char *sideload, ITG *nelemload, double *xloadact, char *lakon, ITG *ipiv, ITG *ntmat_, double *vold, double *shcon, ITG *nshcon, ITG *ipkon, ITG *kon, double *co, ITG *kontri, ITG *ntri, ITG *nloadtr, double *tarea, double *tenv, double *physcon, double *erad, double **adviewp, double **auviewp, ITG *nflow, ITG *ikboun, double *xboun, ITG *nboun, ITG *ithermal, ITG *iinc, ITG *iit, double *cs, ITG *mcs, ITG *inocs, ITG *ntrit, ITG *nk, double *fenv, ITG *istep, double *dtime, double *ttime, double *time, ITG *ilboun, ITG *ikforc, ITG *ilforc, double *xforc, ITG *nforc, double *cam, ITG *ielmat, ITG *nteq, double *prop, ITG *ielprop, ITG *nactdog, ITG *nacteq, ITG *nodeboun, ITG *ndirboun, ITG *network, double *rhcon, ITG *nrhcon, ITG *ipobody, ITG *ibody, double *xbody, ITG *nbody, ITG *iviewfile, char *jobnamef, double *ctrl, double *xloadold, double *reltime, ITG *nmethod, char *set, ITG *mi, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nset, ITG *ineighe, ITG *nmpc, ITG *nodempc, ITG *ipompc, double *coefmpc, char *labmpc, ITG *iemchange, ITG *nam, ITG *iamload, ITG *jqrad, ITG *irowrad, ITG *nzsrad, ITG *icolrad, ITG *ne, ITG *iaxial)
 
void FORTRAN (radmatrix,(ITG *ntr, double *adrad, double *aurad, double *bcr, char *sideload, ITG *nelemload, double *xloadact, char *lakon, double *vold, ITG *ipkon, ITG *kon, double *co, ITG *nloadtr, double *tarea, double *tenv, double *physcon, double *erad, double *adview, double *auview, ITG *ithermal, ITG *iinc, ITG *iit, double *fenv, ITG *istep, double *dtime, double *ttime, double *time, ITG *iviewfile, double *xloadold, double *reltime, ITG *nmethod, ITG *mi, ITG *iemchange, ITG *nam, ITG *iamload, ITG *jqrad, ITG *irowrad, ITG *nzsrad))
 
void FORTRAN (radresult,(ITG *ntr, double *xloadact, double *bcr, ITG *nloadtr, double *tarea, double *tenv, double *physcon, double *erad, double *auview, double *fenv, ITG *irowrad, ITG *jqrad, ITG *nzsrad, double *q))
 
void FORTRAN (readforce,(double *zc, ITG *neq, ITG *nev, ITG *nactdof, ITG *ikmpc, ITG *nmpc, ITG *ipompc, ITG *nodempc, ITG *mi, double *coefmpc, char *jobnamec, double *aa, ITG *igeneralizedforce))
 
void readinput (char *jobnamec, char **inpcp, ITG *nline, ITG *nset, ITG *ipoinp, ITG **inpp, ITG **ipoinpcp, ITG *ithermal)
 
void FORTRAN (readview,(ITG *ntr, double *adview, double *auview, double *fenv, ITG *nzsrad, ITG *ithermal, char *jobnamef))
 
void FORTRAN (rearrange,(double *au, ITG *irow, ITG *icol, ITG *ndim, ITG *neq))
 
void FORTRAN (rectcyl,(double *co, double *v, double *fn, double *stn, double *qfn, double *een, double *cs, ITG *nk, ITG *icntrl, double *t, char *filab, ITG *imag, ITG *mi, double *emn))
 
void FORTRAN (rectcylexp,(double *co, double *v, double *fn, double *stn, double *qfn, double *een, double *cs, ITG *nkt, ITG *icntrl, double *t, char *filab, ITG *imag, ITG *mi, ITG *iznode, ITG *nznode, ITG *nsectors, ITG *nk, double *emn))
 
void FORTRAN (rectcyltrfm,(ITG *node, double *co, double *cs, ITG *cntrl, double *fin, double *fout))
 
void FORTRAN (rectcylvi,(double *co, double *v, double *fn, double *stn, double *qfn, double *een, double *cs, ITG *nk, ITG *icntrl, double *t, char *filab, ITG *imag, ITG *mi, double *emn))
 
void remastruct (ITG *ipompc, double **coefmpcp, ITG **nodempcp, ITG *nmpc, ITG *mpcfree, ITG *nodeboun, ITG *ndirboun, ITG *nboun, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, char *labmpc, ITG *nk, ITG *memmpc_, ITG *icascade, ITG *maxlenmpc, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nactdof, ITG *icol, ITG *jq, ITG **irowp, ITG *isolver, ITG *neq, ITG *nzs, ITG *nmethod, double **fp, double **fextp, double **bp, double **aux2p, double **finip, double **fextinip, double **adbp, double **aubp, ITG *ithermal, ITG *iperturb, ITG *mass, ITG *mi, ITG *iexpl, ITG *mortar, char *typeboun, double **cvp, double **cvinip, ITG *iit)
 
void remastructar (ITG *ipompc, double **coefmpcp, ITG **nodempcp, ITG *nmpc, ITG *mpcfree, ITG *nodeboun, ITG *ndirboun, ITG *nboun, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, char *labmpc, ITG *nk, ITG *memmpc_, ITG *icascade, ITG *maxlenmpc, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nactdof, ITG *icol, ITG *jq, ITG **irowp, ITG *isolver, ITG *neq, ITG *nzs, ITG *nmethod, ITG *ithermal, ITG *iperturb, ITG *mass, ITG *mi, ITG *ics, double *cs, ITG *mcs, ITG *mortar, char *typeboun)
 
void remastructem (ITG *ipompc, double **coefmpcp, ITG **nodempcp, ITG *nmpc, ITG *mpcfree, ITG *nodeboun, ITG *ndirboun, ITG *nboun, ITG *ikmpc, ITG *ilmpc, ITG *ikboun, ITG *ilboun, char *labmpc, ITG *nk, ITG *memmpc_, ITG *icascade, ITG *maxlenmpc, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *nactdof, ITG *icol, ITG *jq, ITG **irowp, ITG *isolver, ITG *neq, ITG *nzs, ITG *nmethod, double **fp, double **fextp, double **bp, double **aux2p, double **finip, double **fextinip, double **adbp, double **aubp, ITG *ithermal, ITG *iperturb, ITG *mass, ITG *mi, ITG *ielmat, double *elcon, ITG *ncmat_, ITG *ntmat_, ITG *inomat)
 
void FORTRAN (restartshort,(ITG *nset, ITG *nload, ITG *nbody, ITG *nforc, ITG *nboun, ITG *nk, ITG *ne, ITG *nmpc, ITG *nalset, ITG *nmat, ITG *ntmat, ITG *npmat, ITG *norien, ITG *nam, ITG *nprint, ITG *mint, ITG *ntrans, ITG *ncs, ITG *namtot, ITG *ncmat, ITG *memmpc, ITG *ne1d, ITG *ne2d, ITG *nflow, char *set, ITG *meminset, ITG *rmeminset, char *jobnamec, ITG *irestartstep, ITG *icntrl, ITG *ithermal, ITG *nener, ITG *nstate_, ITG *ntie, ITG *nslavs, ITG *nkon, ITG *mcs, ITG *nprop, ITG *mortar, ITG *ifacecount, ITG *nintpoint, ITG *infree))
 
void FORTRAN (restartwrite,(ITG *istep, ITG *nset, ITG *nload, ITG *nforc, ITG *nboun, ITG *nk, ITG *ne, ITG *nmpc, ITG *nalset, ITG *nmat, ITG *ntmat_, ITG *npmat_, ITG *norien, ITG *nam, ITG *nprint, ITG *mi, ITG *ntrans, ITG *ncs_, ITG *namtot_, ITG *ncmat_, ITG *mpcend, ITG *maxlenmpc, ITG *ne1d, ITG *ne2d, ITG *nflow, ITG *nlabel, ITG *iplas, ITG *nkon, ITG *ithermal, ITG *nmethod, ITG *iperturb, ITG *nstate_, ITG *nener, char *set, ITG *istartset, ITG *iendset, ITG *ialset, double *co, ITG *kon, ITG *ipkon, char *lakon, ITG *nodeboun, ITG *ndirboun, ITG *iamboun, double *xboun, ITG *ikboun, ITG *ilboun, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *ikmpc, ITG *ilmpc, ITG *nodeforc, ITG *ndirforc, ITG *iamforc, double *xforc, ITG *ikforc, ITG *ilforc, ITG *nelemload, ITG *iamload, char *sideload, double *xload, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, char *orname, double *orab, ITG *ielorien, double *trab, ITG *inotr, char *amname, double *amta, ITG *namta, double *t0, double *t1, ITG *iamt1, double *veold, ITG *ielmat, char *matname, char *prlab, char *prset, char *filab, double *vold, ITG *nodebounold, ITG *ndirbounold, double *xbounold, double *xforcold, double *xloadold, double *t1old, double *eme, ITG *iponor, double *xnor, ITG *knor, double *thicke, double *offset, ITG *iponoel, ITG *inoel, ITG *rig, double *shcon, ITG *nshcon, double *cocon, ITG *ncocon, ITG *ics, double *sti, double *ener, double *xstate, char *jobnamec, ITG *infree, double *prestr, ITG *iprestr, char *cbody, ITG *ibody, double *xbody, ITG *nbody, double *xbodyold, double *ttime, double *qaold, double *cs, ITG *mcs, char *output, double *physcon, double *ctrl, char *typeboun, double *fmpc, char *tieset, ITG *ntie, double *tietol, ITG *nslavs, double *t0g, double *t1g, ITG *nprop, ITG *ielprop, double *prop, ITG *mortar, ITG *nintpoint, ITG *ifacecount, ITG *islavsurf, double *pslavsurf, double *clearini))
 
void FORTRAN (resultnet,(ITG *itg, ITG *ieg, ITG *ntg, double *bc, ITG *nload, char *sideload, ITG *nelemload, double *xloadact, char *lakon, ITG *ntmat_, double *v, double *shcon, ITG *nshcon, ITG *ipkon, ITG *kon, double *co, ITG *nflow, ITG *iinc, ITG *istep, double *dtime, double *ttime, double *time, ITG *ikforc, ITG *ilforc, double *xforcact, ITG *nforc, ITG *ielmat, ITG *nteq, double *prop, ITG *ielprop, ITG *nactdog, ITG *nacteq, ITG *iin, double *physcon, double *camt, double *camf, double *camp, double *rhcon, ITG *nrhcon, ITG *ipobody, ITG *ibody, double *xbody, ITG *nbody, double *dtheta, double *vold, double *xloadold, double *reltime, ITG *nmethod, char *set, ITG *mi, ITG *ineighe, double *cama, double *vamt, double *vamf, double *vamp, double *vama, ITG *nmpc, ITG *nodempc, ITG *ipompc, double *coefmpc, char *labmpc, ITG *iaxial))
 
void results (double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, double *v, double *stn, ITG *inum, double *stx, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, ITG *ithermal, double *prestr, ITG *iprestr, char *filab, double *eme, double *emn, double *een, ITG *iperturb, double *f, double *fn, ITG *nactdof, ITG *iout, double *qa, double *vold, double *b, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *nmpc, ITG *nmethod, double *vmax, ITG *neq, double *veold, double *accold, double *beta, double *gamma, double *dtime, double *time, double *ttime, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstateini, double *xstiff, double *xstate, ITG *npmat_, double *epl, char *matname, ITG *mi, ITG *ielas, ITG *icmd, ITG *ncmat_, ITG *nstate_, double *stiini, double *vini, ITG *ikboun, ITG *ilboun, double *ener, double *enern, double *emeini, double *xstaten, double *eei, double *enerini, double *cocon, ITG *ncocon, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nprint, char *prlab, char *prset, double *qfx, double *qfn, double *trab, ITG *inotr, ITG *ntrans, double *fmpc, ITG *nelemload, ITG *nload, ITG *ikmpc, ITG *ilmpc, ITG *istep, ITG *iinc, double *springarea, double *reltime, ITG *ne0, double *xforc, ITG *nforc, double *thicke, double *shcon, ITG *nshcon, char *sideload, double *xload, double *xloadold, ITG *icfd, ITG *inomat, double *pslavsurf, double *pmastsurf, ITG *mortar, ITG *islavact, double *cdn, ITG *islavnode, ITG *nslavnode, ITG *ntie, double *clearini, ITG *islavsurf, ITG *ielprop, double *prop)
 
void FORTRAN (resultsem,(double *co, ITG *kon, ITG *ipkon, char *lakon, double *v, double *elcon, ITG *nelcon, ITG *ielmat, ITG *ntmat_, double *vold, double *dtime, char *matname, ITG *mi, ITG *ncmat_, ITG *nea, ITG *neb, double *sti, double *alcon, ITG *nalcon, double *h0, ITG *istartset, ITG *iendset, ITG *ialset, ITG *iactive, double *fn))
 
void * resultsemmt (ITG *i)
 
void FORTRAN (resultsforc,(ITG *nk, double *f, double *fn, ITG *nactdof, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *nmpc, ITG *mi, double *fmpc, ITG *calcul_fn, ITG *calcul_f))
 
void FORTRAN (resultsforc_em,(ITG *nk, double *f, double *fn, ITG *nactdof, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *nmpc, ITG *mi, double *fmpc, ITG *calcul_fn, ITG *calcul_f, ITG *inomat))
 
void FORTRAN (resultsini,(ITG *nk, double *v, ITG *ithermal, char *filab, ITG *iperturb, double *f, double *fn, ITG *nactdof, ITG *iout, double *qa, double *vold, double *b, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *nmpc, ITG *nmethod, double *cam, ITG *neq, double *veold, double *accold, double *bet, double *gam, double *dtime, ITG *mi, double *vini, ITG *nprint, char *prlab, ITG *intpointvar, ITG *calcul_fn, ITG *calcul_f, ITG *calcul_qa, ITG *calcul_cauchy, ITG *iener, ITG *ikin, ITG *intpointvart, double *xforc, ITG *nforc))
 
void FORTRAN (resultsini_em,(ITG *nk, double *v, ITG *ithermal, char *filab, ITG *iperturb, double *f, double *fn, ITG *nactdof, ITG *iout, double *qa, double *b, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *nmpc, ITG *nmethod, double *cam, ITG *neq, double *veold, double *dtime, ITG *mi, double *vini, ITG *nprint, char *prlab, ITG *intpointvar, ITG *calcul_fn, ITG *calcul_f, ITG *calcul_qa, ITG *calcul_cauchy, ITG *iener, ITG *ikin, ITG *intpointvart, double *xforc, ITG *nforc))
 
void FORTRAN (resultsmech,(double *co, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, double *v, double *stx, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, ITG *ithermal, double *prestr, ITG *iprestr, double *eme, ITG *iperturb, double *fn, ITG *iout, double *qa, double *vold, ITG *nmethod, double *veold, double *dtime, double *time, double *ttime, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstateini, double *xstiff, double *xstate, ITG *npmat_, char *matname, ITG *mi, ITG *ielas, ITG *icmd, ITG *ncmat_, ITG *nstate_, double *stiini, double *vini, double *ener, double *eei, double *enerini, ITG *istep, ITG *iinc, double *springarea, double *reltime, ITG *calcul_fn, ITG *calcul_qa, ITG *calcul_cauchy, ITG *iener, ITG *ikin, ITG *nal, ITG *ne0, double *thicke, double *emeini, double *pslavsurf, double *pmastsurf, ITG *mortar, double *clearini, ITG *nea, ITG *neb, ITG *ielprop, double *prop))
 
void * resultsmechmt (ITG *i)
 
void FORTRAN (resultsprint,(double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, double *v, double *stn, ITG *inum, double *stx, ITG *ielorien, ITG *norien, double *orab, double *t1, ITG *ithermal, char *filab, double *een, ITG *iperturb, double *fn, ITG *nactdof, ITG *iout, double *vold, ITG *nodeboun, ITG *ndirboun, ITG *nboun, ITG *nmethod, double *ttime, double *xstate, double *epn, ITG *mi, ITG *nstate_, double *ener, double *enern, double *xstaten, double *eei, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nprint, char *prlab, char *prset, double *qfx, double *qfn, double *trab, ITG *inotr, ITG *ntrans, ITG *nelemload, ITG *nload, ITG *ikin, ITG *ielmat, double *thicke, double *eme, double *emn, double *rhcon, ITG *nrhcon, double *shcon, ITG *nshcon, double *cocon, ITG *ncocon, ITG *ntmat_, char *sideload, ITG *icfd, ITG *inomat, double *pslavsurf, ITG *islavact, double *cdn, ITG *mortar, ITG *islavnode, ITG *nslavnode, ITG *ntie, ITG *islavsurf, double *time, ITG *ielprop, double *prop, double *veold))
 
void FORTRAN (resultstherm,(double *co, ITG *kon, ITG *ipkon, char *lakon, double *v, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, ITG *iperturb, double *fn, double *shcon, ITG *nshcon, ITG *iout, double *qa, double *vold, ITG *ipompc, ITG *nodempc, double *coefmpc, ITG *nmpc, double *dtime, double *time, double *ttime, double *plkcon, ITG *nplkcon, double *xstateini, double *xstiff, double *xstate, ITG *npmat_, char *matname, ITG *mi, ITG *ncmat_, ITG *nstate_, double *cocon, ITG *ncocon, double *qfx, ITG *ikmpc, ITG *ilmpc, ITG *istep, ITG *iinc, double *springarea, ITG *calcul_fn, ITG *calcul_qa, ITG *nal, ITG *nea, ITG *neb, ITG *ithermal, ITG *nelemload, ITG *nload, ITG *nmethod, double *reltime, char *sideload, double *xload, double *xloadold, double *pslavsurf, double *pmastsurf, ITG *mortar, double *clearini, double *plicon, ITG *nplicon, ITG *ielprop, double *prop))
 
void * resultsthermemmt (ITG *i)
 
void * resultsthermmt (ITG *i)
 
void resultsinduction (double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, double *v, double *stn, ITG *inum, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, ITG *ithermal, double *prestr, ITG *iprestr, char *filab, double *eme, double *emn, double *een, ITG *iperturb, double *f, double *fn, ITG *nactdof, ITG *iout, double *qa, double *vold, double *b, ITG *nodeboun, ITG *ndirboun, double *xboun, ITG *nboun, ITG *ipompc, ITG *nodempc, double *coefmpc, char *labmpc, ITG *nmpc, ITG *nmethod, double *vmax, ITG *neq, double *veold, double *accold, double *beta, double *gamma, double *dtime, double *time, double *ttime, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstateini, double *xstiff, double *xstate, ITG *npmat_, double *epl, char *matname, ITG *mi, ITG *ielas, ITG *icmd, ITG *ncmat_, ITG *nstate_, double *sti, double *vini, ITG *ikboun, ITG *ilboun, double *ener, double *enern, double *emeini, double *xstaten, double *eei, double *enerini, double *cocon, ITG *ncocon, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nprint, char *prlab, char *prset, double *qfx, double *qfn, double *trab, ITG *inotr, ITG *ntrans, double *fmpc, ITG *nelemload, ITG *nload, ITG *ikmpc, ITG *ilmpc, ITG *istep, ITG *iinc, double *springarea, double *reltime, ITG *ne0, double *xforc, ITG *nforc, double *thicke, double *shcon, ITG *nshcon, char *sideload, double *xload, double *xloadold, ITG *icfd, ITG *inomat, double *h0, ITG *islavnode, ITG *nslavnode, ITG *ntie, ITG *ielprop, double *prop, ITG *iactive)
 
void FORTRAN (rhsp,(ITG *ne, char *lakon, ITG *nactdoh, ITG *ipnei, ITG *neifa, ITG *neiel, double *vfa, double *area, double *adfa, double *xlet, double *cosa, double *volume, double *au, double *ad, ITG *jq, ITG *irow, double *ap, ITG *ielfa, ITG *ifabou, double *xle, double *b, double *xxn, ITG *compressible, ITG *neq, ITG *nzs, double *hfa, double *bp, ITG *neij, double *xxi, double *gradpel, double *xlen))
 
void FORTRAN (shape3tri,(double *xi, double *et, double *xl, double *xsj, double *xs, double *shp, ITG *iflag))
 
void FORTRAN (shape4q,(double *xi, double *et, double *xl, double *xsj, double *xs, double *shp, ITG *iflag))
 
void FORTRAN (shape4tet,(double *xi, double *et, double *ze, double *xl, double *xsj, double *shp, ITG *iflag))
 
void FORTRAN (shape6tri,(double *xi, double *et, double *xl, double *xsj, double *xs, double *shp, ITG *iflag))
 
void FORTRAN (shape6w,(double *xi, double *et, double *ze, double *xl, double *xsj, double *shp, ITG *iflag))
 
void FORTRAN (shape8h,(double *xi, double *et, double *ze, double *xl, double *xsj, double *shp, ITG *iflag))
 
void FORTRAN (shape8q,(double *xi, double *et, double *xl, double *xsj, double *xs, double *shp, ITG *iflag))
 
void FORTRAN (shape10tet,(double *xi, double *et, double *ze, double *xl, double *xsj, double *shp, ITG *iflag))
 
void FORTRAN (shape15w,(double *xi, double *et, double *ze, double *xl, double *xsj, double *shp, ITG *iflag))
 
void FORTRAN (shape20h,(double *xi, double *et, double *ze, double *xl, double *xsj, double *shp, ITG *iflag))
 
void FORTRAN (rhs,(double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, ITG *ipompc, ITG *nodempc, double *coefmpc, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, double *xbody, ITG *ipobody, ITG *nbody, double *cgr, double *bb, ITG *nactdof, ITG *neq, ITG *nmethod, ITG *ikmpc, ITG *ilmpc, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *alcon, ITG *nalcon, double *alzero, ITG *ielmat, ITG *ielorien, ITG *norien, double *orab, ITG *ntmat_, double *t0, double *t1, ITG *ithermal, ITG *iprestr, double *vold, ITG *iperturb, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, ITG *npmat_, double *ttime, double *time, ITG *istep, ITG *iinc, double *dtime, double *physcon, ITG *ibody, double *xbodyold, double *reltime, double *veold, char *matname, ITG *mi, ITG *ikactmech, ITG *nactmech, ITG *ielprop, double *prop))
 
void FORTRAN (slavintpoints,(ITG *ntie, ITG *itietri, ITG *ipkon, ITG *kon, char *lakon, double *straight, ITG *nintpoint, ITG *koncont, double *co, double *vold, double *xo, double *yo, double *zo, double *x, double *y, double *z, ITG *nx, ITG *ny, ITG *nz, ITG *islavsurf, ITG *islavnode, ITG *nslavnode, ITG *imastop, ITG *mi, ITG *ncont, ITG *ipe, ITG *ime, double *pslavsurf, ITG *i, ITG *l, ITG *ntri))
 
void FORTRAN (sortev,(ITG *nev, ITG *nmd, double *eigxx, ITG *cyclicsymmetry, double *xx, double *eigxr, ITG *pev, ITG *istartnmd, ITG *iendnmd, double *aa, double *bb))
 
void FORTRAN (spcmatch,(double *xboun, ITG *nodeboun, ITG *ndirboun, ITG *nboun, double *xbounold, ITG *nodebounold, ITG *ndirbounold, ITG *nbounold, ITG *ikboun, ITG *ilboun, double *vold, double *reorder, ITG *nreorder, ITG *mi))
 
void FORTRAN (splitline,(char *text, char *textpart, ITG *n))
 
void spooles (double *ad, double *au, double *adb, double *aub, double *sigma, double *b, ITG *icol, ITG *irow, ITG *neq, ITG *nzs, ITG *symmtryflag, ITG *inputformat, ITG *nzs3)
 
void FORTRAN (springforc_n2f,(double *xl, ITG *konl, double *vl, ITG *imat, double *elcon, ITG *nelcon, double *elas, double *fnl, ITG *ncmat_, ITG *ntmat_, ITG *nope, char *lakonl, double *t1l, ITG *kode, double *elconloc, double *plicon, ITG *nplicon, ITG *npmat_, double *senergy, ITG *iener, double *cstr, ITG *mi, double *springarea, ITG *nmethod, ITG *ne0, ITG *nstate_, double *xstateini, double *xstate, double *reltime, ITG *ielas))
 
void FORTRAN (springstiff_n2f,(double *xl, double *elas, ITG *konl, double *voldl, double *s, ITG *imat, double *elcon, ITG *nelcon, ITG *ncmat_, ITG *ntmat_, ITG *nope, char *lakonl, double *t1l, ITG *kode, double *elconloc, double *plicon, ITG *nplicon, ITG *npmat_, ITG *iperturb, double *springarea, ITG *nmethod, ITG *mi, ITG *ne0, ITG *nstate_, double *xstateini, double *xstate, double *reltime, ITG *nasym))
 
void steadystate (double **co, ITG *nk, ITG **kon, ITG **ipkon, char **lakon, ITG *ne, ITG **nodeboun, ITG **ndirboun, double **xboun, ITG *nboun, ITG **ipompcp, ITG **nodempcp, double **coefmpcp, char **labmpcp, ITG *nmpc, ITG *nodeforc, ITG *ndirforc, double *xforc, ITG *nforc, ITG *nelemload, char *sideload, double *xload, ITG *nload, ITG **nactdof, ITG *neq, ITG *nzl, ITG *icol, ITG *irow, ITG *nmethod, ITG **ikmpcp, ITG **ilmpcp, ITG **ikboun, ITG **ilboun, double *elcon, ITG *nelcon, double *rhcon, ITG *nrhcon, double *cocon, ITG *ncocon, double *alcon, ITG *nalcon, double *alzero, ITG **ielmat, ITG **ielorien, ITG *norien, double *orab, ITG *ntmat_, double **t0, double **t1, ITG *ithermal, double *prestr, ITG *iprestr, double **voldp, ITG *iperturb, double *sti, ITG *nzs, double *timepar, double *xmodal, double **veoldp, char *amname, double *amta, ITG *namta, ITG *nam, ITG *iamforc, ITG *iamload, ITG **iamt1, ITG *jout, ITG *kode, char *filab, double **emep, double *xforcold, double *xloadold, double **t1old, ITG **iamboun, double **xbounold, ITG *iexpl, double *plicon, ITG *nplicon, double *plkcon, ITG *nplkcon, double *xstate, ITG *npmat_, char *matname, ITG *mi, ITG *ncmat_, ITG *nstate_, double **enerp, char *jobnamec, double *ttime, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *nprint, char *prlab, char *prset, ITG *nener, double *trab, ITG **inotr, ITG *ntrans, double **fmpcp, char *cbody, ITG *ibody, double *xbody, ITG *nbody, double *xbodyold, ITG *istep, ITG *isolver, ITG *jq, char *output, ITG *mcs, ITG *nkon, ITG *ics, double *cs, ITG *mpcend, double *ctrl, ITG *ikforc, ITG *ilforc, double *thicke, ITG *nmat, char *typeboun, ITG *ielprop, double *prop)
 
void FORTRAN (stop,())
 
void storecontactdof (ITG *nope, ITG *nactdof, ITG *mt, ITG *konl, ITG **ikactcontp, ITG *nactcont, ITG *nactcont_, double *bcont, double *fnl, ITG *ikmpc, ITG *nmpc, ITG *ilmpc, ITG *ipompc, ITG *nodempc, double *coefmpc)
 
void FORTRAN (storeresidual,(ITG *nactdof, double *b, double *fn, char *filab, ITG *ithermal, ITG *nk, double *sti, double *stn, ITG *ipkon, ITG *inum, ITG *kon, char *lakon, ITG *ne, ITG *mi, double *orab, ITG *ielorien, double *co, ITG *itg, ITG *ntg, double *vold, ITG *ielmat, double *thicke, ITG *ielprop, double *prop))
 
ITG strcmp1 (const char *s1, const char *s2)
 
ITG strcmp2 (const char *s1, const char *s2, ITG length)
 
ITG strcpy1 (char *s1, const char *s2, ITG length)
 
void FORTRAN (subspace,(double *d, double *aa, double *bb, double *cc, double *alpham, double *betam, ITG *nev, double *xini, double *cd, double *cv, double *time, double *rwork, ITG *lrw, ITG *k, ITG *jout, double *rpar, double *bj, ITG *iwork, ITG *liw, ITG *iddebdf, double *bjp))
 
void FORTRAN (tempload,(double *xforcold, double *xforc, double *xforcact, ITG *iamforc, ITG *nforc, double *xloadold, double *xload, double *xloadact, ITG *iamload, ITG *nload, ITG *ibody, double *xbody, ITG *nbody, double *xbodyold, double *xbodyact, double *t1old, double *t1, double *t1act, ITG *iamt1, ITG *nk, double *amta, ITG *namta, ITG *nam, double *ampli, double *time, double *reltime, double *ttime, double *dtime, ITG *ithermal, ITG *nmethod, double *xbounold, double *xboun, double *xbounact, ITG *iamboun, ITG *nboun, ITG *nodeboun, ITG *ndirboun, ITG *nodeforc, ITG *ndirforc, ITG *istep, ITG *iint, double *co, double *vold, ITG *itg, ITG *ntg, char *amname, ITG *ikboun, ITG *ilboun, ITG *nelemload, char *sideload, ITG *mi, ITG *ntrans, double *trab, ITG *inotr, double *veold, ITG *integerglob, double *doubleglob, char *tieset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *ntie, ITG *nmpc, ITG *ipompc, ITG *ikmpc, ITG *ilmpc, ITG *nodempc, double *coefmpc))
 
void FORTRAN (tempload_em,(double *xforcold, double *xforc, double *xforcact, ITG *iamforc, ITG *nforc, double *xloadold, double *xload, double *xloadact, ITG *iamload, ITG *nload, ITG *ibody, double *xbody, ITG *nbody, double *xbodyold, double *xbodyact, double *t1old, double *t1, double *t1act, ITG *iamt1, ITG *nk, double *amta, ITG *namta, ITG *nam, double *ampli, double *time, double *reltime, double *ttime, double *dtime, ITG *ithermal, ITG *nmethod, double *xbounold, double *xboun, double *xbounact, ITG *iamboun, ITG *nboun, ITG *nodeboun, ITG *ndirboun, ITG *nodeforc, ITG *ndirforc, ITG *istep, ITG *iint, double *co, double *vold, ITG *itg, ITG *ntg, char *amname, ITG *ikboun, ITG *ilboun, ITG *nelemload, char *sideload, ITG *mi, ITG *ntrans, double *trab, ITG *inotr, double *veold, ITG *integerglob, double *doubleglob, char *tieset, ITG *istartset, ITG *iendset, ITG *ialset, ITG *ntie, ITG *nmpc, ITG *ipompc, ITG *ikmpc, ITG *ilmpc, ITG *nodempc, double *coefmpc, double *h0scale, ITG *inomat))
 
void FORTRAN (temploaddiff,(double *xforcold, double *xforc, double *xforcact, ITG *iamforc, ITG *nforc, double *xloadold, double *xload, double *xloadact, ITG *iamload, ITG *nload, ITG *ibody, double *xbody, ITG *nbody, double *xbodyold, double *xbodyact, double *t1old, double *t1, double *t1act, ITG *iamt1, ITG *nk, double *amta, ITG *namta, ITG *nam, double *ampli, double *time, double *reltime, double *ttime, double *dtime, ITG *ithermal, ITG *nmethod, double *xbounold, double *xboun, double *xbounact, ITG *iamboun, ITG *nboun, ITG *nodeboun, ITG *ndirboun, ITG *nodeforc, ITG *ndirforc, ITG *istep, ITG *iint, double *co, double *vold, ITG *itg, ITG *ntg, char *amname, ITG *ikboun, ITG *ilboun, ITG *nelemload, char *sideload, ITG *mi, double *xforcdiff, double *xloaddiff, double *xbodydiff, double *t1diff, double *xboundiff, ITG *icorrect, ITG *iprescribedboundary, ITG *ntrans, double *trab, ITG *inotr, double *veold, ITG *nactdof, double *bcont, double *fn))
 
void FORTRAN (temploadmodal,(double *amta, ITG *namta, ITG *nam, double *ampli, double *timemin, double *ttimemin, double *dtime, double *xbounold, double *xboun, double *xbounmin, ITG *iamboun, ITG *nboun, ITG *nodeboun, ITG *ndirboun, char *amname))
 
void FORTRAN (tiefaccont,(char *lakon, ITG *ipkon, ITG *kon, ITG *ntie, char *tieset, ITG *nset, char *set, ITG *istartset, ITG *iendset, ITG *ialset, ITG *itiefac, ITG *islavsurf, ITG *islavnode, ITG *imastnode, ITG *nslavnode, ITG *nmastnode, ITG *nslavs, ITG *nmasts, ITG *ifacecount, ITG *iponoels, ITG *inoels, ITG *ifreenoels, ITG *mortar, ITG *ipoface, ITG *nodface, ITG *nk, double *xnoels))
 
void tiedcontact (ITG *ntie, char *tieset, ITG *nset, char *set, ITG *istartset, ITG *iendset, ITG *ialset, char *lakon, ITG *ipkon, ITG *kon, double *tietol, ITG *nmpc, ITG *mpcfree, ITG *memmpc_, ITG **ipompcp, char **labmpcp, ITG **ikmpcp, ITG **ilmpcp, double **fmpcp, ITG **nodempcp, double **coefmpcp, ITG *ithermal, double *co, double *vold, ITG *cfd, ITG *nmpc_, ITG *mi, ITG *nk, ITG *istep, ITG *ikboun, ITG *nboun, char *kind1, char *kind2)
 
void FORTRAN (transformatrix,(double *xab, double *p, double *a))
 
void FORTRAN (trianeighbor,(ITG *ipe, ITG *ime, ITG *imastop, ITG *ncont, ITG *koncont, ITG *ifreeme))
 
void FORTRAN (triangucont,(ITG *ncont, ITG *ntie, char *tieset, ITG *nset, char *set, ITG *istartset, ITG *iendset, ITG *ialset, ITG *itietri, char *lakon, ITG *ipkon, ITG *kon, ITG *koncont, char *kind1, char *kind2, double *co, ITG *nk))
 
void FORTRAN (ufaceload,(double *co, ITG *ipkon, ITG *kon, char *lakon, ITG *nboun, ITG *nodeboun, ITG *nelemload, char *sideload, ITG *nload, ITG *ne, ITG *nk))
 
void FORTRAN (uinit,())
 
void FORTRAN (uout,(double *v, ITG *mi, ITG *ithermal))
 
void FORTRAN (updatecont,(ITG *koncont, ITG *ncont, double *co, double *vold, double *cg, double *straight, ITG *mi))
 
void FORTRAN (updatecontpen,(ITG *koncont, ITG *ncont, double *co, double *vold, double *cg, double *straight, ITG *mi, ITG *imastnode, ITG *nmastnode, double *xmastnor, ITG *ntie, char *tieset, ITG *nset, char *set, ITG *istartset, ITG *iendset, ITG *ialset, ITG *ipkon, char *lakon, ITG *kon, double *cs, ITG *mcs, ITG *ics))
 
void * u_calloc (size_t num, size_t size, const char *file, const int line, const char *ptr_name)
 
void * u_free (void *num, const char *file, const int line, const char *ptr_name)
 
void * u_realloc (void *num, size_t size, const char *file, const int line, const char *ptr_name)
 
void writeBasisParameter (FILE *f, ITG *istep, ITG *iinc)
 
void FORTRAN (writeboun,(ITG *nodeboun, ITG *ndirboun, double *xboun, char *typeboun, ITG *nboun))
 
void FORTRAN (writebv,(double *, ITG *))
 
void FORTRAN (writecvg,(ITG *itep, ITG *iinc, ITG *iit, ITG *ne, ITG *ne0, double *ram, double *qam, double *cam, double *uam, ITG *ithermal))
 
void FORTRAN (writeev,(double *, ITG *, double *, double *))
 
void FORTRAN (writeevcomplex,(double *eigxx, ITG *nev, double *fmin, double *fmax))
 
void FORTRAN (writeevcs,(double *, ITG *, ITG *, double *, double *))
 
void FORTRAN (writeevcscomplex,(double *eigxx, ITG *nev, ITG *nm, double *fmin, double *fmax))
 
void FORTRAN (writehe,(ITG *))
 
void writeheading (char *jobnamec, char *heading, ITG *nheading)
 
void FORTRAN (writeim,())
 
void FORTRAN (writeinput,(char *inpc, ITG *ipoinp, ITG *inp, ITG *nline, ITG *ninp, ITG *ipoinpc))
 
void FORTRAN (writemac,(double *mac, ITG *nev))
 
void FORTRAN (writemaccs,(double *mac, ITG *nev, ITG *nm))
 
void FORTRAN (writempc,(ITG *, ITG *, double *, char *, ITG *))
 
void FORTRAN (writepf,(double *d, double *bjr, double *bji, double *freq, ITG *nev, ITG *mode, ITG *nherm))
 
void FORTRAN (writere,())
 
void FORTRAN (writesubmatrix,(double *submatrix, ITG *noderetain, ITG *ndirretain, ITG *nretain, char *jobnamec))
 
void FORTRAN (writesummary,(ITG *istep, ITG *j, ITG *icutb, ITG *l, double *ttime, double *time, double *dtime))
 
void FORTRAN (writesummarydiv,(ITG *istep, ITG *j, ITG *icutb, ITG *l, double *ttime, double *time, double *dtime))
 
void FORTRAN (writetetmesh,(ITG *kontet, ITG *netet_, double *cotet, ITG *nktet, double *field, ITG *nfield))
 
void FORTRAN (writeview,(ITG *ntr, double *adview, double *auview, double *fenv, ITG *nzsrad, char *jobnamef))
 
void FORTRAN (zienzhu,(double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne, double *stn, ITG *ipneigh, ITG *neigh, double *sti, ITG *mi))
 
void FORTRAN (znaupd,(ITG *ido, char *bmat, ITG *n, char *which, ITG *nev, double *tol, double *resid, ITG *ncv, double *z, ITG *ldz, ITG *iparam, ITG *ipntr, double *workd, double *workl, ITG *lworkl, double *rwork, ITG *info))
 
void FORTRAN (zneupd,(ITG *rvec, char *howmny, ITG *select, double *d, double *z, ITG *ldz, double *sigma, double *workev, char *bmat, ITG *neq, char *which, ITG *nev, double *tol, double *resid, ITG *ncv, double *v, ITG *ldv, ITG *iparam, ITG *ipntr, double *workd, double *workl, ITG *lworkl, double *rwork, ITG *info))
 

Macro Definition Documentation

#define DMEMSET (   a,
  b,
  c,
 
)    for(im=b;im<c;im++)a[im]=d

Definition at line 45 of file CalculiX.h.

#define HP   4

Definition at line 21 of file CalculiX.h.

#define IRIX   2

Definition at line 19 of file CalculiX.h.

#define IRIX64   3

Definition at line 20 of file CalculiX.h.

#define ITG   int

Definition at line 51 of file CalculiX.h.

#define ITGFORMAT   "d"

Definition at line 52 of file CalculiX.h.

#define Linux   1

Definition at line 18 of file CalculiX.h.

#define NNEW (   a,
  b,
 
)    a=(b *)u_calloc((c),sizeof(b),__FILE__,__LINE__,#a)

Definition at line 39 of file CalculiX.h.

#define RENEW (   a,
  b,
 
)    a=(b *)u_realloc((b *)(a),(c)*sizeof(b),__FILE__,__LINE__,#a)

Definition at line 40 of file CalculiX.h.

#define SFREE (   a)    u_free(a,__FILE__,__LINE__,#a)

Definition at line 41 of file CalculiX.h.

Function Documentation

void arpack ( double *  co,
ITG nk,
ITG **  konp,
ITG **  ipkonp,
char **  lakonp,
ITG ne,
ITG nodeboun,
ITG ndirboun,
double *  xboun,
ITG nboun,
ITG ipompc,
ITG nodempc,
double *  coefmpc,
char *  labmpc,
ITG nmpc,
ITG nodeforc,
ITG ndirforc,
double *  xforc,
ITG nforc,
ITG nelemload,
char *  sideload,
double *  xload,
ITG nload,
ITG nactdof,
ITG icol,
ITG jq,
ITG **  irowp,
ITG neq,
ITG nzl,
ITG nmethod,
ITG ikmpc,
ITG ilmpc,
ITG ikboun,
ITG ilboun,
double *  elcon,
ITG nelcon,
double *  rhcon,
ITG nrhcon,
double *  shcon,
ITG nshcon,
double *  cocon,
ITG ncocon,
double *  alcon,
ITG nalcon,
double *  alzero,
ITG **  ielmatp,
ITG **  ielorienp,
ITG norien,
double *  orab,
ITG ntmat_,
double *  t0,
double *  t1,
double *  t1old,
ITG ithermal,
double *  prestr,
ITG iprestr,
double *  vold,
ITG iperturb,
double *  sti,
ITG nzs,
ITG kode,
ITG mei,
double *  fei,
char *  filab,
double *  eme,
ITG iexpl,
double *  plicon,
ITG nplicon,
double *  plkcon,
ITG nplkcon,
double **  xstatep,
ITG npmat_,
char *  matname,
ITG mi,
ITG ncmat_,
ITG nstate_,
double **  enerp,
char *  jobnamec,
char *  output,
char *  set,
ITG nset,
ITG istartset,
ITG iendset,
ITG ialset,
ITG nprint,
char *  prlab,
char *  prset,
ITG nener,
ITG isolver,
double *  trab,
ITG inotr,
ITG ntrans,
double *  ttime,
double *  fmpc,
char *  cbody,
ITG ibody,
double *  xbody,
ITG nbody,
double *  thicke,
ITG nslavs,
double *  tietol,
ITG nkon,
ITG mpcinfo,
ITG ntie,
ITG istep,
ITG mcs,
ITG ics,
char *  tieset,
double *  cs,
ITG nintpoint,
ITG mortar,
ITG ifacecount,
ITG **  islavsurfp,
double **  pslavsurfp,
double **  clearinip,
ITG nmat,
char *  typeboun,
ITG ielprop,
double *  prop 
)
void arpackbu ( double *  co,
ITG nk,
ITG kon,
ITG ipkon,
char *  lakon,
ITG ne,
ITG nodeboun,
ITG ndirboun,
double *  xboun,
ITG nboun,
ITG ipompc,
ITG nodempc,
double *  coefmpc,
char *  labmpc,
ITG nmpc,
ITG nodeforc,
ITG ndirforc,
double *  xforc,
ITG nforc,
ITG nelemload,
char *  sideload,
double *  xload,
ITG nload,
ITG nactdof,
ITG icol,
ITG jq,
ITG irow,
ITG neq,
ITG nzl,
ITG nmethod,
ITG ikmpc,
ITG ilmpc,
ITG ikboun,
ITG ilboun,
double *  elcon,
ITG nelcon,
double *  rhcon,
ITG nrhcon,
double *  alcon,
ITG nalcon,
double *  alzero,
ITG ielmat,
ITG ielorien,
ITG norien,
double *  orab,
ITG ntmat_,
double *  t0,
double *  t1,
double *  t1old,
ITG ithermal,
double *  prestr,
ITG iprestr,
double *  vold,
ITG iperturb,
double *  sti,
ITG nzs,
ITG kode,
ITG mei,
double *  fei,
char *  filab,
double *  eme,
ITG iexpl,
double *  plicon,
ITG nplicon,
double *  plkcon,
ITG nplkcon,
double *  xstate,
ITG npmat_,
char *  matname,
ITG mi,
ITG ncmat_,
ITG nstate_,
double *  ener,
char *  output,
char *  set,
ITG nset,
ITG istartset,
ITG iendset,
ITG ialset,
ITG nprint,
char *  prlab,
char *  prset,
ITG nener,
ITG isolver,
double *  trab,
ITG inotr,
ITG ntrans,
double *  ttime,
double *  fmpc,
char *  cbody,
ITG ibody,
double *  xbody,
ITG nbody,
double *  thicke,
char *  jobnamec,
ITG nmat,
ITG ielprop,
double *  prop 
)
void arpackcs ( double *  co,
ITG nk,
ITG **  konp,
ITG **  ipkonp,
char **  lakonp,
ITG ne,
ITG nodeboun,
ITG ndirboun,
double *  xboun,
ITG nboun,
ITG ipompc,
ITG nodempc,
double *  coefmpc,
char *  labmpc,
ITG nmpc,
ITG nodeforc,
ITG ndirforc,
double *  xforc,
ITG nforc,
ITG nelemload,
char *  sideload,
double *  xload,
ITG nload,
ITG nactdof,
ITG icol,
ITG jq,
ITG **  irowp,
ITG neq,
ITG nzl,
ITG nmethod,
ITG ikmpc,
ITG ilmpc,
ITG ikboun,
ITG ilboun,
double *  elcon,
ITG nelcon,
double *  rhcon,
ITG nrhcon,
double *  alcon,
ITG nalcon,
double *  alzero,
ITG **  ielmatp,
ITG **  ielorienp,
ITG norien,
double *  orab,
ITG ntmat_,
double *  t0,
double *  t1,
double *  t1old,
ITG ithermal,
double *  prestr,
ITG iprestr,
double *  vold,
ITG iperturb,
double *  sti,
ITG nzs,
ITG kode,
ITG mei,
double *  fei,
char *  filab,
double *  eme,
ITG iexpl,
double *  plicon,
ITG nplicon,
double *  plkcon,
ITG nplkcon,
double **  xstatep,
ITG npmat_,
char *  matname,
ITG mi,
ITG ics,
double *  cs,
ITG mpcend,
ITG ncmat_,
ITG nstate_,
ITG mcs,
ITG nkon,
double **  enerp,
char *  jobnamec,
char *  output,
char *  set,
ITG nset,
ITG istartset,
ITG iendset,
ITG ialset,
ITG nprint,
char *  prlab,
char *  prset,
ITG nener,
ITG isolver,
double *  trab,
ITG inotr,
ITG ntrans,
double *  ttime,
double *  fmpc,
char *  cbody,
ITG ibody,
double *  xbody,
ITG nbody,
ITG nevtot,
double *  thicke,
ITG nslavs,
double *  tietol,
ITG mpcinfo,
ITG ntie,
ITG istep,
char *  tieset,
ITG nintpoint,
ITG mortar,
ITG ifacecount,
ITG **  islavsurfp,
double **  pslavsurfp,
double **  clearinip,
ITG nmat,
char *  typeboun,
ITG ielprop,
double *  prop 
)
void biosav ( ITG ipkon,
ITG kon,
char *  lakon,
ITG ne,
double *  co,
double *  qfx,
double *  h0,
ITG mi,
ITG inomat,
ITG nk 
)

Definition at line 31 of file biosav.c.

32  {
33 
34  ITG i,j,*ithread=NULL,nkphi,idelta,isum;
35 
36  /* calculates the magnetic intensity due to currents in the phi-
37  domain of an electromagnetic calculation */
38 
39  /* variables for multithreading procedure */
40 
41  ITG sys_cpus;
42  char *env,*envloc,*envsys;
43 
44  num_cpus = 0;
45  sys_cpus=0;
46 
47  /* explicit user declaration prevails */
48 
49  envsys=getenv("NUMBER_OF_CPUS");
50  if(envsys){
51  sys_cpus=atoi(envsys);
52  if(sys_cpus<0) sys_cpus=0;
53  }
54 
55  /* automatic detection of available number of processors */
56 
57  if(sys_cpus==0){
58  sys_cpus = getSystemCPUs();
59  if(sys_cpus<1) sys_cpus=1;
60  }
61 
62  /* local declaration prevails, if strictly positive */
63 
64  envloc = getenv("CCX_NPROC_BIOTSAVART");
65  if(envloc){
66  num_cpus=atoi(envloc);
67  if(num_cpus<0){
68  num_cpus=0;
69  }else if(num_cpus>sys_cpus){
70  num_cpus=sys_cpus;
71  }
72  }
73 
74  /* else global declaration, if any, applies */
75 
76  env = getenv("OMP_NUM_THREADS");
77  if(num_cpus==0){
78  if (env)
79  num_cpus = atoi(env);
80  if (num_cpus < 1) {
81  num_cpus=1;
82  }else if(num_cpus>sys_cpus){
83  num_cpus=sys_cpus;
84  }
85  }
86 
87  /* determining the nodal bounds in each thread */
88 
91 
92  /* n1 is the number of nodes in the phi(magnetostatic)-domain in
93  an electromagnetic calculation */
94 
95  nkphi=0;
96  for(i=0;i<*nk;i++){
97  if(inomat[i]==1) nkphi++;
98  }
99  if(nkphi<num_cpus) num_cpus=nkphi;
100 
101  idelta=nkphi/num_cpus;
102 
103  /* dividing the range from 1 to the number of phi-nodes */
104 
105  isum=0;
106  for(i=0;i<num_cpus;i++){
107  nkapar[i]=isum;
108  if(i!=num_cpus-1){
109  isum+=idelta;
110  }else{
111  isum=nkphi;
112  }
113  nkepar[i]=isum-1;
114  }
115 
116  /* translating the bounds of the ranges to real node numbers */
117 
118  i=0;
119  j=0;
120  nkphi=-1;
121 
122  do{
123  if(j==num_cpus) break;
124  do{
125  if(nkapar[j]==nkphi){
126  nkapar[j]=i;
127  break;
128  }else{
129  do{
130  i++;
131  if(inomat[i]==1){
132  nkphi++;
133  break;
134  }
135  }while(1);
136  }
137  }while(1);
138 
139  do{
140  if(nkepar[j]==nkphi){
141  nkepar[j]=i;
142  j++;
143  break;
144  }else{
145  do{
146  i++;
147  if(inomat[i]==1){
148  nkphi++;
149  break;
150  }
151  }while(1);
152  }
153  }while(1);
154  }while(1);
155 
156  ipkon1=ipkon;kon1=kon;lakon1=lakon;ne1=ne;co1=co;qfx1=qfx;
157  h01=h0;mi1=mi;
158 
159  printf(" Using up to %" ITGFORMAT " cpu(s) for the Biot-Savart calculation.\n\n", num_cpus);
160 
161  /* create threads and wait */
162 
163  pthread_t tid[num_cpus];
164 
165  NNEW(ithread,ITG,num_cpus);
166  for(i=0;i<num_cpus;i++){
167  ithread[i]=i;
168  pthread_create(&tid[i],NULL,(void *)biotsavartmt,(void *)&ithread[i]);
169  }
170  for(i=0;i<num_cpus;i++)pthread_join(tid[i], NULL);
171 
172  SFREE(ithread);SFREE(nkapar);SFREE(nkepar);
173 
174  return;
175 
176 }
#define ITGFORMAT
Definition: CalculiX.h:52
int pthread_create(pthread_t *thread_id, const pthread_attr_t *attributes, void *(*thread_function)(void *), void *arguments)
static ITG num_cpus
Definition: biosav.c:27
static ITG * ne1
Definition: biosav.c:27
static char * lakon1
Definition: biosav.c:25
static ITG * mi1
Definition: biosav.c:27
void * biotsavartmt(ITG *i)
Definition: biosav.c:180
static ITG * ipkon1
Definition: biosav.c:27
ITG getSystemCPUs()
Definition: getSystemCPUs.c:40
static double * qfx1
Definition: biosav.c:29
static double * co1
Definition: biosav.c:29
static ITG * nkapar
Definition: biosav.c:27
#define SFREE(a)
Definition: CalculiX.h:41
int pthread_join(pthread_t thread, void **status_ptr)
#define ITG
Definition: CalculiX.h:51
static ITG * kon1
Definition: biosav.c:27
static ITG * nkepar
Definition: biosav.c:27
#define NNEW(a, b, c)
Definition: CalculiX.h:39
static double * h01
Definition: biosav.c:29
void* biotsavartmt ( ITG i)

Definition at line 180 of file biosav.c.

180  {
181 
182  ITG nka,nkb;
183 
184  nka=nkapar[*i]+1;
185  nkb=nkepar[*i]+1;
186 
188  &nkb));
189 
190  return NULL;
191 }
subroutine biotsavart(ipkon, kon, lakon, ne, co, qfx, h0, mi, nka, nkb)
Definition: biotsavart.f:19
static ITG * ne1
Definition: biosav.c:27
static char * lakon1
Definition: biosav.c:25
void FORTRAN(addimdnodecload,(ITG *nodeforc, ITG *i, ITG *imdnode, ITG *nmdnode, double *xforc, ITG *ikmpc, ITG *ilmpc, ITG *ipompc, ITG *nodempc, ITG *nmpc, ITG *imddof, ITG *nmddof, ITG *nactdof, ITG *mi, ITG *imdmpc, ITG *nmdmpc, ITG *imdboun, ITG *nmdboun, ITG *ikboun, ITG *nboun, ITG *ilboun, ITG *ithermal))
static ITG * mi1
Definition: biosav.c:27
static ITG * ipkon1
Definition: biosav.c:27
static double * qfx1
Definition: biosav.c:29
static double * co1
Definition: biosav.c:29
static ITG * nkapar
Definition: biosav.c:27
#define ITG
Definition: CalculiX.h:51
static ITG * kon1
Definition: biosav.c:27
static ITG * nkepar
Definition: biosav.c:27
static double * h01
Definition: biosav.c:29
void calcresidual ( ITG nmethod,
ITG neq,
double *  b,
double *  fext,
double *  f,
ITG iexpl,
ITG nactdof,
double *  aux2,
double *  vold,
double *  vini,
double *  dtime,
double *  accold,
ITG nk,
double *  adb,
double *  aub,
ITG icol,
ITG irow,
ITG nzl,
double *  alpha,
double *  fextini,
double *  fini,
ITG islavnode,
ITG nslavnode,
ITG mortar,
ITG ntie,
double *  f_cm,
double *  f_cs,
ITG mi,
ITG nzs,
ITG nasym,
ITG idamping,
double *  veold,
double *  adc,
double *  auc,
double *  cvini,
double *  cv 
)

Definition at line 33 of file calcresidual.c.

40  {
41 
42  ITG j,k,mt=mi[1]+1;
43  double scal1;
44 
45  /* residual for a static analysis */
46 
47  if(*nmethod!=4){
48  for(k=0;k<neq[1];++k){
49  b[k]=fext[k]-f[k];
50  }
51  }
52 
53  /* residual for implicit dynamics */
54 
55  else if(*iexpl<=1){
56  for(k=0;k<*nk;++k){
57  if(nactdof[mt*k]!=0){
58  aux2[nactdof[mt*k]-1]=(vold[mt*k]-vini[mt*k])/(*dtime);}
59  for(j=1;j<mt;++j){
60  if(nactdof[mt*k+j]!=0){aux2[nactdof[mt*k+j]-1]=accold[mt*k+j];}
61  }
62  }
63  if(*nasym==0){
64  FORTRAN(op,(&neq[1],aux2,b,adb,aub,jq,irow));
65  }else{
66  FORTRAN(opas,(&neq[1],aux2,b,adb,aub,jq,irow,nzs));
67  }
68  scal1=1.+*alpha;
69  for(k=0;k<neq[0];++k){
70  b[k]=scal1*(fext[k]-f[k])-*alpha*(fextini[k]-fini[k])-b[k];
71  }
72  for(k=neq[0];k<neq[1];++k){
73  b[k]=fext[k]-f[k]-b[k];
74  }
75 
76  /* correction for damping */
77 
78  if(*idamping==1){
79  for(k=0;k<*nk;++k){
80  if(nactdof[mt*k]!=0){aux2[nactdof[mt*k]-1]=0.;}
81  for(j=1;j<mt;++j){
82  if(nactdof[mt*k+j]!=0){
83  aux2[nactdof[mt*k+j]-1]=veold[mt*k+j];}
84  }
85  }
86  if(*nasym==0){
87  FORTRAN(op,(&neq[1],aux2,cv,adc,auc,jq,irow));
88  }else{
89  FORTRAN(opas,(&neq[1],aux2,cv,adc,auc,jq,irow,nzs));
90  }
91  for(k=0;k<neq[0];++k){
92  b[k]-=scal1*cv[k]-*alpha*cvini[k];
93  }
94  }
95  }
96 
97  /* residual for explicit dynamics */
98 
99  else{
100  for(k=0;k<*nk;++k){
101  if(nactdof[mt*k]!=0){
102  aux2[nactdof[mt*k]-1]=(vold[mt*k]-vini[mt*k])/(*dtime);}
103  for(j=1;j<mt;++j){
104  if(nactdof[mt*k+j]!=0){aux2[nactdof[mt*k+j]-1]=accold[mt*k+j];}
105  }
106  }
107  scal1=1.+*alpha;
108  for(k=0;k<neq[0];++k){
109  b[k]=scal1*(fext[k]-f[k])-*alpha*(fextini[k]-fini[k])
110  -adb[k]*aux2[k];
111  }
112  for(k=neq[0];k<neq[1];++k){
113  b[k]=fext[k]-f[k]-adb[k]*aux2[k];
114  }
115  }
116 
117  return;
118 }
void FORTRAN(addimdnodecload,(ITG *nodeforc, ITG *i, ITG *imdnode, ITG *nmdnode, double *xforc, ITG *ikmpc, ITG *ilmpc, ITG *ipompc, ITG *nodempc, ITG *nmpc, ITG *imddof, ITG *nmddof, ITG *nactdof, ITG *mi, ITG *imdmpc, ITG *nmdmpc, ITG *imdboun, ITG *nmdboun, ITG *ikboun, ITG *nboun, ITG *ilboun, ITG *ithermal))
subroutine op(n, x, y, ad, au, jq, irow)
Definition: op.f:25
subroutine opas(n, x, y, ad, au, jq, irow, nzs)
Definition: opas.f:25
#define ITG
Definition: CalculiX.h:51
void calcresidual_em ( ITG nmethod,
ITG neq,
double *  b,
double *  fext,
double *  f,
ITG iexpl,
ITG nactdof,
double *  aux1,
double *  aux2,
double *  vold,
double *  vini,
double *  dtime,
double *  accold,
ITG nk,
double *  adb,
double *  aub,
ITG icol,
ITG irow,
ITG nzl,
double *  alpha,
double *  fextini,
double *  fini,
ITG islavnode,
ITG nslavnode,
ITG mortar,
ITG ntie,
double *  f_cm,
double *  f_cs,
ITG mi,
ITG nzs,
ITG nasym,
ITG ithermal 
)

Definition at line 33 of file calcresidual_em.c.

39  {
40 
41  ITG j,k,mt=mi[1]+1,jstart;
42 
43  /* residual for a static analysis */
44 
45  if(*nmethod!=4){
46  for(k=0;k<neq[1];++k){
47  b[k]=fext[k]-f[k];
48  }
49  }
50 
51  /* residual for implicit dynamics */
52 
53  else{
54 
55  if(*ithermal<2){
56  jstart=1;
57  }else{
58  jstart=0;
59  }
60 
61  /* calculating a pseudo-velocity */
62 
63  for(k=0;k<*nk;++k){
64  for(j=jstart;j<mt;++j){
65  if(nactdof[mt*k+j]!=0){aux2[nactdof[mt*k+j]-1]=(vold[mt*k+j]-vini[mt*k+j])/(*dtime);}
66  }
67  }
68 
69  /* calculating "capacity"-matrix times pseudo-velocity */
70 
71  if(*nasym==0){
72  FORTRAN(op,(&neq[1],aux2,b,adb,aub,jq,irow));
73  }else{
74  FORTRAN(opas,(&neq[1],aux2,b,adb,aub,jq,irow,nzs));
75  }
76 
77  for(k=0;k<neq[1];++k){
78  b[k]=fext[k]-f[k]-b[k];
79  }
80  }
81 
82  return;
83 }
void FORTRAN(addimdnodecload,(ITG *nodeforc, ITG *i, ITG *imdnode, ITG *nmdnode, double *xforc, ITG *ikmpc, ITG *ilmpc, ITG *ipompc, ITG *nodempc, ITG *nmpc, ITG *imddof, ITG *nmddof, ITG *nactdof, ITG *mi, ITG *imdmpc, ITG *nmdmpc, ITG *imdboun, ITG *nmdboun, ITG *ikboun, ITG *nboun, ITG *ilboun, ITG *ithermal))
subroutine op(n, x, y, ad, au, jq, irow)
Definition: op.f:25
subroutine opas(n, x, y, ad, au, jq, irow, nzs)
Definition: opas.f:25
#define ITG
Definition: CalculiX.h:51
void* calcviewmt ( ITG i)

Definition at line 549 of file radflowload.c.

549  {
550 
551  ITG indexad,indexau,indexdi,ntria,ntrib,nedelta;
552 
553  indexad=*i**ntr1;
554  indexau=*i*2**nzsrad1;
555  indexdi=*i**ntrit1;
556 
557  nedelta=(ITG)ceil(*ntri1/(double)num_cpus);
558  ntria=*i*nedelta+1;
559  ntrib=(*i+1)*nedelta;
560  if(ntrib>*ntri1) ntrib=*ntri1;
561 
562 // printf("i=%" ITGFORMAT ",ntria=%" ITGFORMAT ",ntrib=%" ITGFORMAT "\n",i,ntria,ntrib);
563 // printf("indexad=%" ITGFORMAT ",indexau=%" ITGFORMAT ",indexdi=%" ITGFORMAT "\n",indexad,indexau,indexdi);
564 
566  kontri1,nloadtr1,&adview[indexad],
567  &auview[indexau],&dist[indexdi],&idist[indexdi],area1,
568  ntrit1,mi1,jqrad1,irowrad1,nzsrad1,&sidemean1,
569  &ntria,&ntrib));
570 
571  return NULL;
572 }
static ITG * mi1
Definition: radflowload.c:39
static double * co1
Definition: radflowload.c:42
subroutine calcview(sideload, vold, co, pmid, e1, e2, e3, kontri, nloadtr, adview, auview, dist, idist, area, ntrit, mi, jqrad, irowrad, nzsrad, sidemean, ntria, ntrib)
Definition: calcview.f:26
static double * pmid1
Definition: radflowload.c:42
static ITG * ntri1
Definition: radflowload.c:39
void FORTRAN(addimdnodecload,(ITG *nodeforc, ITG *i, ITG *imdnode, ITG *nmdnode, double *xforc, ITG *ikmpc, ITG *ilmpc, ITG *ipompc, ITG *nodempc, ITG *nmpc, ITG *imddof, ITG *nmddof, ITG *nactdof, ITG *mi, ITG *imdmpc, ITG *nmdmpc, ITG *imdboun, ITG *nmdboun, ITG *ikboun, ITG *nboun, ITG *ilboun, ITG *ithermal))
static ITG * ntrit1
Definition: radflowload.c:39
static ITG * nloadtr1
Definition: radflowload.c:39
static ITG * ntr1
Definition: radflowload.c:39
static double * e31
Definition: radflowload.c:42
static ITG * idist
Definition: radflowload.c:39
static double sidemean1
Definition: radflowload.c:42
static char * sideload1
Definition: radflowload.c:37
static double * dist
Definition: radflowload.c:42
static double * area1
Definition: radflowload.c:42
static double * vold1
Definition: radflowload.c:42
static double * e21
Definition: radflowload.c:42
static double * adview
Definition: radflowload.c:42
static ITG * jqrad1
Definition: radflowload.c:39
static double * e11
Definition: radflowload.c:42
static ITG * nzsrad1
Definition: radflowload.c:39
static ITG * kontri1
Definition: radflowload.c:39
static ITG num_cpus
Definition: radflowload.c:39
#define ITG
Definition: CalculiX.h:51
static ITG * irowrad1
Definition: radflowload.c:39
static double * auview
Definition: radflowload.c:42
void cascade ( ITG ipompc,
double **  coefmpcp,
ITG **  nodempcp,
ITG nmpc,
ITG mpcfree,
ITG nodeboun,
ITG ndirboun,
ITG nboun,
ITG ikmpc,
ITG ilmpc,
ITG ikboun,
ITG ilboun,
ITG mpcend,
ITG mpcmult,
char *  labmpc,
ITG nk,
ITG memmpc_,
ITG icascade,
ITG maxlenmpc,
ITG callfrommain,
ITG iperturb,
ITG ithermal 
)

Definition at line 34 of file cascade.c.

38  {
39 
40  /* detects cascaded mpc's and decascades them; checks multiple
41  occurrence of the same dependent DOF's in different mpc/spc's
42 
43  data structure of ipompc,coefmpc,nodempc:
44  for each mpc, e.g. i,
45  -the nodes are stored in nodempc(1,ipompc(i)),
46  nodempc(1,nodempc(3,ipompc(i))),
47  nodempc(1,nodempc(3,nodempc(3,ipompc(i))))... till
48  nodempc(3,nodempc(3,nodempc(3,.......))))))=0;
49  -the corresponding directions in nodempc(2,ipompc(i)),
50  nodempc(2,nodempc(3,ipompc(i))),.....
51  -the corresponding coefficient in coefmpc(ipompc(i)),
52  coefmpc(nodempc(3,ipompc(i))),.....
53  the mpc is written as a(1)u(i1,j1)+a(2)u(i2,j2)+...
54  +....a(k)u(ik,jk)=0, the first term is the dependent term,
55  the others are independent, at least after execution of the
56  present routine. The mpc's must be homogeneous, otherwise a
57  error message is generated and the program stops. */
58 
59  ITG i,j,index,id,idof,nterm,idepend,*nodempc=NULL,
60  ispooles,iexpand,ichange,indexold,ifluidmpc,
61  mpc,indexnew,index1,index2,index1old,index2old,*jmpc=NULL,nl;
62 
63  double coef,*coefmpc=NULL;
64 
65 #ifdef SPOOLES
66 
67  ITG irow,icolumn,node,idir,irownl,icolnl,*ipointer=NULL,*icoef=NULL,
68  ifree,*indepdof=NULL,nindep;
69 
70  double *xcoef=NULL,b;
71 
72  DenseMtx *mtxB, *mtxX ;
73  Chv *rootchv ;
74  ChvManager *chvmanager ;
75  SubMtxManager *mtxmanager ;
76  FrontMtx *frontmtx ;
77  InpMtx *mtxA ;
78  double tau = 100.;
79  double cpus[10] ;
80  ETree *frontETree ;
81  FILE *msgFile ;
82  Graph *graph ;
83  ITG jrhs, msglvl=0, nedges,error,
84  nent, neqns, nrhs, pivotingflag=1, seed=389,
85  symmetryflag=2, type=1,maxdomainsize,maxzeros,maxsize;
86  ITG *oldToNew ;
87  ITG stats[20] ;
88  IV *newToOldIV, *oldToNewIV ;
89  IVL *adjIVL, *symbfacIVL ;
90 #endif
91 
92  nodempc=*nodempcp;
93  coefmpc=*coefmpcp;
94 
95  /* for(i=0;i<*nmpc;i++){
96  j=i+1;
97  FORTRAN(writempc,(ipompc,nodempc,coefmpc,labmpc,&j));
98  }*/
99 
100  NNEW(jmpc,ITG,*nmpc);
101  idepend=0;
102 
103 /* check whether a node is used as a dependent node in a MPC
104  and in a SPC */
105 
106  for(i=0;i<*nmpc;i++){
107  if(*nboun>0){
108  FORTRAN(nident,(ikboun,&ikmpc[i],nboun,&id));}
109  else{id=0;}
110  if(id>0){
111  if(ikboun[id-1]==ikmpc[i]){
112  if(strcmp1(&labmpc[20*i],"FLUID")!=0){
113  printf("*ERROR in cascade: the DOF corresponding to \n node %" ITGFORMAT " in direction %" ITGFORMAT " is detected on the \n dependent side of a MPC and a SPC\n",
114  (ikmpc[i])/8+1,ikmpc[i]-8*((ikmpc[i])/8));
115  }else{
116  printf("*ERROR in cascade: the DOF corresponding to \n face %" ITGFORMAT " in direction %" ITGFORMAT " is detected on the \n dependent side of a MPC and a SPC\n",
117  (-ikmpc[i])/8+1,-ikmpc[i]-8*((-ikmpc[i])/8));
118  }
119  FORTRAN(stop,());
120  }
121  }
122  }
123 
124 /* check whether there are user mpc's: in user MPC's the
125  dependent DOF can change, however, the number of terms
126  cannot change */
127 
128  for(i=0;i<*nmpc;i++){
129 
130  /* linear mpc */
131 
132  /* because of the next line the size of field labmpc
133  has to be defined as 20*nmpc+1: without "+1" an
134  undefined field is accessed */
135 
136  if((strcmp1(&labmpc[20*i]," ")==0) ||
137  (strcmp1(&labmpc[20*i],"CYCLIC")==0) ||
138  (strcmp1(&labmpc[20*i],"SUBCYCLIC")==0)||
139  (strcmp1(&labmpc[20*i],"CONTACT")==0)||
140  (strcmp1(&labmpc[20*i],"FLUID")==0)||
141  (*iperturb<2)) jmpc[i]=0;
142 
143  /* nonlinear mpc */
144 
145  else if((strcmp1(&labmpc[20*i],"RIGID")==0) ||
146  (strcmp1(&labmpc[20*i],"KNOT")==0) ||
147  (strcmp1(&labmpc[20*i],"PLANE")==0) ||
148  (strcmp1(&labmpc[20*i],"STRAIGHT")==0)||
149  (strcmp1(&labmpc[20*i],"ISOCHORIC")==0)) jmpc[i]=1;
150 
151  /* user mpc */
152 
153  else{
154  jmpc[i]=1;
155  if(*icascade==0) *icascade=1;
156  }
157  }
158 
159 /* decascading */
160 
161  ispooles=0;
162 
163  /* decascading using simple substitution */
164 
165  do{
166  ichange=0;
167  for(i=0;i<*nmpc;i++){
168 
169  if(strcmp1(&labmpc[20*i],"FLUID")!=0){
170  ifluidmpc=0;
171  }else{
172  ifluidmpc=1;
173  }
174 
175  if(jmpc[i]==1) nl=1;
176  else nl=0;
177  iexpand=0;
178  index=nodempc[3*ipompc[i]-1];
179  if(index==0) continue;
180  do{
181  if(ifluidmpc==0){
182  /* MPC on node */
183  idof=(nodempc[3*index-3]-1)*8+nodempc[3*index-2];
184  }else{
185  if(nodempc[3*index-3]>0){
186  /* MPC on face */
187  idof=-((nodempc[3*index-3]-1)*8+nodempc[3*index-2]);
188  }else{
189  /* MPC on node
190  SPC number: -nodempc[3*index-3]
191  node: nodeboun[-nodempc[3*index-3]-1] */
192 
193  idof=(nodeboun[-nodempc[3*index-3]-1]-1)*8+nodempc[3*index-2];
194  }
195  }
196 
197  FORTRAN(nident,(ikmpc,&idof,nmpc,&id));
198  if((id>0)&&(ikmpc[id-1]==idof)){
199 
200  /* a term on the independent side of the MPC is
201  detected as dependent node in another MPC */
202 
203  indexold=nodempc[3*index-1];
204  coef=coefmpc[index-1];
205  mpc=ilmpc[id-1];
206 
207  /* no expansion if there is a dependence of a
208  nonlinear MPC on another linear or nonlinear MPC
209  and the call is from main */
210 
211  if((jmpc[mpc-1]==1)||(nl==1)){
212  *icascade=2;
213  if(idepend==0){
214  printf("*INFO in cascade: linear MPCs and\n");
215  printf(" nonlinear MPCs depend on each other\n");
216  printf(" common node: %" ITGFORMAT " in direction %" ITGFORMAT "\n\n",nodempc[3*index-3],nodempc[3*index-2]);
217  idepend=1;}
218  if(*callfrommain==1){
219  index=nodempc[3*index-1];
220  if(index!=0) continue;
221  else break;}
222  }
223 
224 /* printf("*INFO in cascade: DOF %" ITGFORMAT " of node %" ITGFORMAT " is expanded\n",
225  nodempc[3*index-2],nodempc[3*index-3]);*/
226 
227  /* collecting terms corresponding to the same DOF */
228 
229  index1=ipompc[i];
230  do{
231  index2old=index1;
232  index2=nodempc[3*index1-1];
233  if(index2==0) break;
234  do{
235  if((nodempc[3*index1-3]==nodempc[3*index2-3])&&
236  (nodempc[3*index1-2]==nodempc[3*index2-2])){
237  coefmpc[index1-1]+=coefmpc[index2-1];
238  nodempc[3*index2old-1]=nodempc[3*index2-1];
239  nodempc[3*index2-1]=*mpcfree;
240  *mpcfree=index2;
241  index2=nodempc[3*index2old-1];
242  if(index2==0) break;
243  }
244  else{
245  index2old=index2;
246  index2=nodempc[3*index2-1];
247  if(index2==0) break;
248  }
249  }while(1);
250  index1=nodempc[3*index1-1];
251  if(index1==0) break;
252  }while(1);
253 
254  /* check for zero coefficients on the dependent side */
255 
256  index1=ipompc[i];
257  if(fabs(coefmpc[index1-1])<1.e-10){
258  printf("*ERROR in cascade: zero coefficient on the\n");
259  printf(" dependent side of an equation\n");
260  printf(" dependent node: %" ITGFORMAT "",nodempc[3*index1-3]);
261  printf(" direction: %" ITGFORMAT "",nodempc[3*index1-2]);
262  FORTRAN(stop,());
263  }
264 
265  ichange=1;iexpand=1;
266  if((strcmp1(&labmpc[20*i]," ")==0)&&
267  (strcmp1(&labmpc[20*(mpc-1)],"CYCLIC")==0))
268  strcpy1(&labmpc[20*i],"SUBCYCLIC",9);
269  indexnew=ipompc[mpc-1];
270  coef=-coef/coefmpc[indexnew-1];
271  indexnew=nodempc[3*indexnew-1];
272  do{
273  coefmpc[index-1]=coef*coefmpc[indexnew-1];
274  nodempc[3*index-3]=nodempc[3*indexnew-3];
275  nodempc[3*index-2]=nodempc[3*indexnew-2];
276  indexnew=nodempc[3*indexnew-1];
277  if(indexnew!=0){
278  nodempc[3*index-1]=*mpcfree;
279  index=*mpcfree;
280  *mpcfree=nodempc[3**mpcfree-1];
281  if(*mpcfree==0){
282  *mpcfree=*memmpc_+1;
283  nodempc[3*index-1]=*mpcfree;
284  *memmpc_=(ITG)(1.1**memmpc_);
285  printf("*INFO in cascade: reallocating nodempc; new size = %" ITGFORMAT "\n\n",*memmpc_);
286  RENEW(nodempc,ITG,3**memmpc_);
287  RENEW(coefmpc,double,*memmpc_);
288  for(j=*mpcfree;j<*memmpc_;j++){
289  nodempc[3*j-1]=j+1;
290  }
291  nodempc[3**memmpc_-1]=0;
292  }
293  continue;
294  }
295  else{
296  nodempc[3*index-1]=indexold;
297  break;
298  }
299  }while(1);
300  break;
301  }
302  else{
303  index=nodempc[3*index-1];
304  if(index!=0) continue;
305  else break;
306  }
307  }while(1);
308  if(iexpand==0) continue;
309 
310  /* one term of the mpc was expanded
311  collecting terms corresponding to the same DOF */
312 
313  index1=ipompc[i];
314  do{
315  index2old=index1;
316  index2=nodempc[3*index1-1];
317  if(index2==0) break;
318  do{
319  if((nodempc[3*index1-3]==nodempc[3*index2-3])&&
320  (nodempc[3*index1-2]==nodempc[3*index2-2])){
321  coefmpc[index1-1]+=coefmpc[index2-1];
322  nodempc[3*index2old-1]=nodempc[3*index2-1];
323  nodempc[3*index2-1]=*mpcfree;
324  *mpcfree=index2;
325  index2=nodempc[3*index2old-1];
326  if(index2==0) break;
327  }
328  else{
329  index2old=index2;
330  index2=nodempc[3*index2-1];
331  if(index2==0) break;
332  }
333  }while(1);
334  index1=nodempc[3*index1-1];
335  if(index1==0) break;
336  }while(1);
337 
338  /* check for zero coefficients on the dependent and
339  independent side */
340 
341  index1=ipompc[i];
342  index1old=0;
343  do {
344  if(fabs(coefmpc[index1-1])<1.e-10){
345  if(index1old==0){
346  printf("*ERROR in cascade: zero coefficient on the\n");
347  printf(" dependent side of an equation\n");
348  printf(" dependent node: %" ITGFORMAT "",nodempc[3*index1-3]);
349  printf(" direction: %" ITGFORMAT "",nodempc[3*index1-2]);
350  FORTRAN(stop,());
351  }
352  else{
353  nodempc[3*index1old-1]=nodempc[3*index1-1];
354  nodempc[3*index1-1]=*mpcfree;
355  *mpcfree=index1;
356  index1=nodempc[3*index1old-1];
357  }
358  }
359  else{
360  index1old=index1;
361  index1=nodempc[3*index1-1];
362  }
363  if(index1==0) break;
364  }while(1);
365  }
366  if(ichange==0) break;
367  }while(1);
368 
369  /* decascading using spooles */
370 
371 #ifdef SPOOLES
372  if((*icascade==1)&&(ispooles==1)){
373  if ( (msgFile = fopen("spooles.out", "a")) == NULL ) {
374  fprintf(stderr, "\n fatal error in spooles.c"
375  "\n unable to open file spooles.out\n") ;
376  }
377  NNEW(ipointer,ITG,7**nk);
378  NNEW(indepdof,ITG,7**nk);
379  NNEW(icoef,ITG,2**memmpc_);
380  NNEW(xcoef,double,*memmpc_);
381  ifree=0;
382  nindep=0;
383 
384  for(i=*nmpc-1;i>-1;i--){
385  index=ipompc[i];
386  while(1){
387  idof=8*(nodempc[3*index-3]-1)+nodempc[3*index-2]-1;
388 
389 /* check whether idof is a independent dof which has not yet been
390  stored in indepdof */
391 
392  FORTRAN(nident,(ikmpc,&idof,nmpc,&id));
393  if((id==0)||(ikmpc[id-1]!=idof)){
394  FORTRAN(nident,(indepdof,&idof,&nindep,&id));
395  if((id==0)||(indepdof[id-1]!=idof)){
396  for(j=nindep;j>id;j--){
397  indepdof[j]=indepdof[j-1];
398  }
399  indepdof[id]=idof;
400  nindep++;
401  }
402  }
403 
404  icoef[2*ifree]=i+1;
405  icoef[2*ifree+1]=ipointer[idof];
406  xcoef[ifree]=coefmpc[index-1];
407  ipointer[idof]=++ifree;
408  index=nodempc[3*index-1];
409  if(index==0) break;
410  }
411  }
412 
413 /* filling the left hand side */
414 
415  nent=*memmpc_;
416  neqns=*nmpc;
417  mtxA = InpMtx_new() ;
418  InpMtx_init(mtxA, INPMTX_BY_ROWS, type, nent, neqns) ;
419 
420  for(i=0;i<*nmpc;i++){
421  idof=ikmpc[i];
422  icolumn=ilmpc[i]-1;
423  if(strcmp1(&labmpc[20*icolumn],"RIGID")==0) icolnl=1;
424  else icolnl=0;
425  index=ipointer[idof-1];
426  while(1){
427  irow=icoef[2*index-2]-1;
428  if(irow!=icolumn){
429  if(strcmp1(&labmpc[20*irow],"RIGID")==0)irownl=1;
430  else irownl=0;
431  if((irownl==1)||(icolnl==1)){
432  *icascade=2;
433  InpMtx_free(mtxA);
434  printf("*ERROR in cascade: linear and nonlinear MPCs depend on each other");
435  FORTRAN(stop,());
436  }
437  }
438  if((strcmp1(&labmpc[20*irow]," ")==0)&&
439  (strcmp1(&labmpc[20*icolumn],"CYCLIC")==0)){
440  strcpy1(&labmpc[20*irow],"SUBCYCLIC",9);}
441  coef=xcoef[index-1];
442  InpMtx_inputRealEntry(mtxA,irow,icolumn,coef);
443  index=icoef[2*index-1];
444  if(index==0) break;
445  }
446  ipointer[idof-1]=0;
447  }
448 
449  InpMtx_changeStorageMode(mtxA, INPMTX_BY_VECTORS) ;
450  if ( msglvl > 1 ) {
451  fprintf(msgFile, "\n\n input matrix") ;
452  InpMtx_writeForHumanEye(mtxA, msgFile) ;
453  fflush(msgFile) ;
454  }
455 /*--------------------------------------------------------------------*/
456 /*
457  -------------------------------------------------
458  STEP 2 : find a low-fill ordering
459  (1) create the Graph object
460  (2) order the graph using multiple minimum degree
461  -------------------------------------------------
462 */
463  graph = Graph_new() ;
464  adjIVL = InpMtx_fullAdjacency(mtxA) ;
465  nedges = IVL_tsize(adjIVL) ;
466  Graph_init2(graph, 0, neqns, 0, nedges, neqns, nedges, adjIVL,
467  NULL, NULL) ;
468  if ( msglvl > 1 ) {
469  fprintf(msgFile, "\n\n graph of the input matrix") ;
470  Graph_writeForHumanEye(graph, msgFile) ;
471  fflush(msgFile) ;
472  }
473  maxdomainsize=800;maxzeros=1000;maxsize=64;
474  /*maxdomainsize=neqns/100;*/
475  /*frontETree = orderViaMMD(graph, seed, msglvl, msgFile) ;*/
476  /*frontETree = orderViaND(graph,maxdomainsize,seed,msglvl,msgFile); */
477  /*frontETree = orderViaMS(graph,maxdomainsize,seed,msglvl,msgFile);*/
478  frontETree=orderViaBestOfNDandMS(graph,maxdomainsize,maxzeros,
479  maxsize,seed,msglvl,msgFile);
480  if ( msglvl > 1 ) {
481  fprintf(msgFile, "\n\n front tree from ordering") ;
482  ETree_writeForHumanEye(frontETree, msgFile) ;
483  fflush(msgFile) ;
484  }
485 /*--------------------------------------------------------------------*/
486 /*
487  -----------------------------------------------------
488  STEP 3: get the permutation, permute the matrix and
489  front tree and get the symbolic factorization
490  -----------------------------------------------------
491 */
492  oldToNewIV = ETree_oldToNewVtxPerm(frontETree) ;
493  oldToNew = IV_entries(oldToNewIV) ;
494  newToOldIV = ETree_newToOldVtxPerm(frontETree) ;
495  ETree_permuteVertices(frontETree, oldToNewIV) ;
496  InpMtx_permute(mtxA, oldToNew, oldToNew) ;
497 /* InpMtx_mapToUpperTriangle(mtxA) ;*/
498  InpMtx_changeCoordType(mtxA,INPMTX_BY_CHEVRONS);
499  InpMtx_changeStorageMode(mtxA,INPMTX_BY_VECTORS);
500  symbfacIVL = SymbFac_initFromInpMtx(frontETree, mtxA) ;
501  if ( msglvl > 1 ) {
502  fprintf(msgFile, "\n\n old-to-new permutation vector") ;
503  IV_writeForHumanEye(oldToNewIV, msgFile) ;
504  fprintf(msgFile, "\n\n new-to-old permutation vector") ;
505  IV_writeForHumanEye(newToOldIV, msgFile) ;
506  fprintf(msgFile, "\n\n front tree after permutation") ;
507  ETree_writeForHumanEye(frontETree, msgFile) ;
508  fprintf(msgFile, "\n\n input matrix after permutation") ;
509  InpMtx_writeForHumanEye(mtxA, msgFile) ;
510  fprintf(msgFile, "\n\n symbolic factorization") ;
511  IVL_writeForHumanEye(symbfacIVL, msgFile) ;
512  fflush(msgFile) ;
513  }
514 /*--------------------------------------------------------------------*/
515 /*
516  ------------------------------------------
517  STEP 4: initialize the front matrix object
518  ------------------------------------------
519 */
520  frontmtx = FrontMtx_new() ;
521  mtxmanager = SubMtxManager_new() ;
522  SubMtxManager_init(mtxmanager, NO_LOCK, 0) ;
523  FrontMtx_init(frontmtx, frontETree, symbfacIVL, type, symmetryflag,
524  FRONTMTX_DENSE_FRONTS, pivotingflag, NO_LOCK, 0, NULL,
525  mtxmanager, msglvl, msgFile) ;
526 /*--------------------------------------------------------------------*/
527 /*
528  -----------------------------------------
529  STEP 5: compute the numeric factorization
530  -----------------------------------------
531 */
532  chvmanager = ChvManager_new() ;
533  ChvManager_init(chvmanager, NO_LOCK, 1) ;
534  DVfill(10, cpus, 0.0) ;
535  IVfill(20, stats, 0) ;
536  rootchv = FrontMtx_factorInpMtx(frontmtx, mtxA, tau, 0.0, chvmanager,
537  &error,cpus, stats, msglvl, msgFile) ;
538  ChvManager_free(chvmanager) ;
539  if ( msglvl > 1 ) {
540  fprintf(msgFile, "\n\n factor matrix") ;
541  FrontMtx_writeForHumanEye(frontmtx, msgFile) ;
542  fflush(msgFile) ;
543  }
544  if ( rootchv != NULL ) {
545  fprintf(msgFile, "\n\n matrix found to be singular\n") ;
546  exit(-1) ;
547  }
548  if(error>=0){
549  fprintf(msgFile,"\n\nerror encountered at front %" ITGFORMAT "",error);
550  exit(-1);
551  }
552 /*--------------------------------------------------------------------*/
553 /*
554  --------------------------------------
555  STEP 6: post-process the factorization
556  --------------------------------------
557 */
558  FrontMtx_postProcess(frontmtx, msglvl, msgFile) ;
559  if ( msglvl > 1 ) {
560  fprintf(msgFile, "\n\n factor matrix after post-processing") ;
561  FrontMtx_writeForHumanEye(frontmtx, msgFile) ;
562  fflush(msgFile) ;
563  }
564 
565 /* reinitialize nodempc */
566 
567  *mpcfree=1;
568  for(j=0;j<*nmpc;j++){
569  ipompc[j]=0;}
570 
571 /* filling the RHS */
572 
573  jrhs=0;
574  nrhs=1;
575  mtxB=DenseMtx_new();
576  mtxX=DenseMtx_new();
577 
578  for(i=nindep;i>0;i--){
579  idof=indepdof[i-1];
580  if(ipointer[idof]>0){
581 
582 /* new RHS column */
583 
584  DenseMtx_init(mtxB, type, 0, 0, neqns, nrhs, 1, neqns) ;
585  DenseMtx_zero(mtxB) ;
586 
587  index=ipointer[idof];
588  while(1){
589  irow=icoef[2*index-2]-1;
590  coef=xcoef[index-1];
591  DenseMtx_setRealEntry(mtxB,irow,jrhs,coef);
592  index=icoef[2*index-1];
593  if(index==0) break;
594  }
595 
596  if ( msglvl > 1 ) {
597  fprintf(msgFile, "\n\n rhs matrix in original ordering") ;
598  DenseMtx_writeForHumanEye(mtxB, msgFile) ;
599  fflush(msgFile) ;
600  }
601 
602 /*--------------------------------------------------------------------*/
603 /*
604  ---------------------------------------------------------
605  STEP 8: permute the right hand side into the new ordering
606  ---------------------------------------------------------
607 */
608  DenseMtx_permuteRows(mtxB, oldToNewIV) ;
609  if ( msglvl > 1 ) {
610  fprintf(msgFile, "\n\n right hand side matrix in new ordering") ;
611  DenseMtx_writeForHumanEye(mtxB, msgFile) ;
612  fflush(msgFile) ;
613  }
614 /*--------------------------------------------------------------------*/
615 /*
616  -------------------------------
617  STEP 9: solve the linear system
618  -------------------------------
619 */
620  DenseMtx_init(mtxX, type, 0, 0, neqns, nrhs, 1, neqns) ;
621  DenseMtx_zero(mtxX) ;
622  FrontMtx_solve(frontmtx, mtxX, mtxB, mtxmanager,cpus, msglvl, msgFile) ;
623  if ( msglvl > 1 ) {
624  fprintf(msgFile, "\n\n solution matrix in new ordering") ;
625  DenseMtx_writeForHumanEye(mtxX, msgFile) ;
626  fflush(msgFile) ;
627  }
628 /*--------------------------------------------------------------------*/
629 /*
630  --------------------------------------------------------
631  STEP 10: permute the solution into the original ordering
632  --------------------------------------------------------
633 */
634  DenseMtx_permuteRows(mtxX, newToOldIV) ;
635  if ( msglvl > 1 ) {
636  fprintf(msgFile, "\n\n solution matrix in original ordering") ;
637  DenseMtx_writeForHumanEye(mtxX, msgFile) ;
638  fflush(msgFile) ;
639  }
640 
641 
642  for(j=0;j<*nmpc;j++){
643  b=DenseMtx_entries(mtxX)[j];
644  if(fabs(b)>1.e-10){
645  nodempc[3**mpcfree-1]=ipompc[j];
646  node=(ITG)((idof+8)/8);
647  idir=idof+1-8*(node-1);
648  nodempc[3**mpcfree-3]=node;
649  nodempc[3**mpcfree-2]=idir;
650  coefmpc[*mpcfree-1]=b;
651  ipompc[j]=(*mpcfree)++;
652  if(*mpcfree>*memmpc_){
653  *memmpc_=(ITG)(1.1**memmpc_);
654  RENEW(nodempc,ITG,3**memmpc_);
655  RENEW(coefmpc,double,*memmpc_);
656  }
657  }
658  }
659  }
660  }
661 /*--------------------------------------------------------------------*/
662 /*
663  -----------
664  free memory
665  -----------
666 */
667  FrontMtx_free(frontmtx) ;
668  DenseMtx_free(mtxB) ;
669  DenseMtx_free(mtxX) ;
670  IV_free(newToOldIV) ;
671  IV_free(oldToNewIV) ;
672  InpMtx_free(mtxA) ;
673  ETree_free(frontETree) ;
674  IVL_free(symbfacIVL) ;
675  SubMtxManager_free(mtxmanager) ;
676  Graph_free(graph) ;
677 
678 /* diagonal terms */
679 
680  for(i=0;i<*nmpc;i++){
681  j=ilmpc[i]-1;
682  idof=ikmpc[i];
683  node=(ITG)((idof+7)/8);
684  idir=idof-8*(node-1);
685  nodempc[3**mpcfree-1]=ipompc[j];
686  nodempc[3**mpcfree-3]=node;
687  nodempc[3**mpcfree-2]=idir;
688  coefmpc[*mpcfree-1]=1.;
689  ipompc[j]=(*mpcfree)++;
690  if(*mpcfree>*memmpc_){
691  *memmpc_=(ITG)(1.1**memmpc_);
692  RENEW(nodempc,ITG,3**memmpc_);
693  RENEW(coefmpc,double,*memmpc_);
694  }
695  }
696 
697  SFREE(ipointer);SFREE(indepdof);SFREE(icoef);SFREE(xcoef);
698 
699  fclose(msgFile);
700 
701  }
702 #endif
703 
704 /* determining the effective size of nodempc and coefmpc for
705  the reallocation*/
706 
707  *mpcend=0;
708  *mpcmult=0;
709  *maxlenmpc=0;
710  for(i=0;i<*nmpc;i++){
711  index=ipompc[i];
712  *mpcend=max(*mpcend,index);
713  nterm=1;
714  while(1){
715  index=nodempc[3*index-1];
716  if(index==0){
717  *mpcmult+=nterm*(nterm-1);
718  *maxlenmpc=max(*maxlenmpc,nterm);
719  break;
720  }
721  *mpcend=max(*mpcend,index);
722  nterm++;
723  }
724  }
725 
726  SFREE(jmpc);
727 
728  *nodempcp=nodempc;
729  *coefmpcp=coefmpc;
730 
731 /* for(i=0;i<*nmpc;i++){
732  j=i+1;
733  FORTRAN(writempc,(ipompc,nodempc,coefmpc,labmpc,&j));
734  }*/
735 
736  return;
737 }
#define ITGFORMAT
Definition: CalculiX.h:52
#define max(a, b)
Definition: cascade.c:32
void FORTRAN(addimdnodecload,(ITG *nodeforc, ITG *i, ITG *imdnode, ITG *nmdnode, double *xforc, ITG *ikmpc, ITG *ilmpc, ITG *ipompc, ITG *nodempc, ITG *nmpc, ITG *imddof, ITG *nmddof, ITG *nactdof, ITG *mi, ITG *imdmpc, ITG *nmdmpc, ITG *imdboun, ITG *nmdboun, ITG *ikboun, ITG *nboun, ITG *ilboun, ITG *ithermal))
ITG strcpy1(char *s1, const char *s2, ITG length)
Definition: strcpy1.c:24
ITG strcmp1(const char *s1, const char *s2)
Definition: strcmp1.c:24
subroutine stop()
Definition: stop.f:19
void tau(double *ad, double **aup, double *adb, double *aubp, double *sigma, double *b, ITG *icol, ITG **irowp, ITG *neq, ITG *nzs)
#define RENEW(a, b, c)
Definition: CalculiX.h:40
#define SFREE(a)
Definition: CalculiX.h:41
subroutine nident(x, px, n, id)
Definition: nident.f:25
#define ITG
Definition: CalculiX.h:51
#define NNEW(a, b, c)
Definition: CalculiX.h:39
void CEE ( ddotc  ,
(ITG *n, double *dx, ITG *incx, double *dy, ITG *incy, double *funcddot)   
)
ITG cgsolver ( double *  A,
double *  x,
double *  b,
ITG  neq,
ITG  len,
ITG ia,
ITG iz,
double *  eps,
ITG niter,
ITG  precFlg 
)

Definition at line 70 of file pcgsolver.c.

73 {
74  ITG i=0;
75  double *Factor=NULL,*r=NULL,*p=NULL,*z=NULL,*C=NULL,*g=NULL,*rho=NULL;
76 
77  /* reduce row and column indices by 1 (FORTRAN->C) */
78 
79  for (i=0; i<neq; i++) --iz[i];
80  for (i=0; i<len; i++) --ia[i];
81 
82  /* Scaling the equation system A x + b = 0 */
83 
84  NNEW(Factor,double,neq);
85  Scaling(A,b,neq,ia,iz,Factor);
86 
87  /* SOLVER/PRECONDITIONING TYPE */
88 
89  /* Conjugate gradient solver without preconditioning */
90 
91  if (!precFlg)
92  {
93  NNEW(r,double,neq);
94  NNEW(p,double,neq);
95  NNEW(z,double,neq);
96  CG(A,x,b,neq,len,ia,iz,eps,niter,r,p,z);
97  SFREE(r);SFREE(p);SFREE(z);
98  }
99 
100  /* Conjugate gradient solver with incomplete Cholesky preconditioning on
101  full matrix */
102 
103  else if (precFlg==3)
104  {
105  NNEW(rho,double,neq);
106  NNEW(r,double,neq);
107  NNEW(g,double,neq);
108  NNEW(C,double,len);
109  NNEW(z,double,neq);
110  PCG(A,x,b,neq,len,ia,iz,eps,niter,precFlg,rho,r,g,C,z);
111  SFREE(rho);SFREE(r);SFREE(g);SFREE(C);SFREE(z);
112  }
113 
114  /* Backscaling of the solution vector */
115 
116  for (i=0; i<neq; i++) x[i] *= Factor[i];
117 
118  /* That's it */
119 
120  SFREE(Factor);
121  return GOOD;
122 }
#define GOOD
Definition: pcgsolver.c:25
void CG(double *A, double *x, double *b, ITG neq, ITG len, ITG *ia, ITG *iz, double *eps, ITG *niter, double *r, double *p, double *z)
Definition: pcgsolver.c:504
void Scaling(double *A, double *b, ITG neq, ITG *ia, ITG *iz, double *d)
Definition: pcgsolver.c:281
#define SFREE(a)
Definition: CalculiX.h:41
#define ITG
Definition: CalculiX.h:51
#define NNEW(a, b, c)
Definition: CalculiX.h:39
void PCG(double *A, double *x, double *b, ITG neq, ITG len, ITG *ia, ITG *iz, double *eps, ITG *niter, ITG precFlg, double *rho, double *r, double *g, double *C, double *z)
Definition: pcgsolver.c:147
void checkconvergence ( double *  co,
ITG nk,
ITG kon,
ITG ipkon,
char *  lakon,
ITG ne,
double *  stn,
ITG nmethod,
ITG kode,
char *  filab,
double *  een,
double *  t1act,
double *  time,
double *  epn,
ITG ielmat,
char *  matname,
double *  enern,
double *  xstaten,
ITG nstate_,
ITG istep,
ITG iinc,
ITG iperturb,
double *  ener,
ITG mi,
char *  output,
ITG ithermal,
double *  qfn,
ITG mode,
ITG noddiam,
double *  trab,
ITG inotr,
ITG ntrans,
double *  orab,
ITG ielorien,
ITG norien,
char *  description,
double *  sti,
ITG icutb,
ITG iit,
double *  dtime,
double *  qa,
double *  vold,
double *  qam,
double *  ram1,
double *  ram2,
double *  ram,
double *  cam,
double *  uam,
ITG ntg,
double *  ttime,
ITG icntrl,
double *  theta,
double *  dtheta,
double *  veold,
double *  vini,
ITG idrct,
double *  tper,
ITG istab,
double *  tmax,
ITG nactdof,
double *  b,
double *  tmin,
double *  ctrl,
double *  amta,
ITG namta,
ITG itpamp,
ITG inext,
double *  dthetaref,
ITG itp,
ITG jprint,
ITG jout,
ITG uncoupled,
double *  t1,
ITG iitterm,
ITG nelemload,
ITG nload,
ITG nodeboun,
ITG nboun,
ITG itg,
ITG ndirboun,
double *  deltmx,
ITG iflagact,
char *  set,
ITG nset,
ITG istartset,
ITG iendset,
ITG ialset,
double *  emn,
double *  thicke,
char *  jobnamec,
ITG mortar,
ITG nmat,
ITG ielprop,
double *  prop 
)

Definition at line 33 of file checkconvergence.c.

53  {
54 
55  ITG i0,ir,ip,ic,il,ig,ia,iest,iest1=0,iest2=0,iconvergence,idivergence,
56  ngraph=1,k,*ipneigh=NULL,*neigh=NULL,*inum=NULL,id,istart,iend,inew,
57  i,j,mt=mi[1]+1,iexceed;
58 
59  double df,dc,db,dd,ran,can,rap,ea,cae,ral,da,*vr=NULL,*vi=NULL,*stnr=NULL,
60  *stni=NULL,*vmax=NULL,*stnmax=NULL,*cs=NULL,c1[2],c2[2],reftime,
61  *fn=NULL,*eenmax=NULL,*fnr=NULL,*fni=NULL,*qfx=NULL,*cdn=NULL,
62  *cdnr=NULL,*cdni=NULL;
63 
64  /* next lines are active if the number of contact elements was
65  changed in the present increment */
66 
67  if ((*iflagact==1)&&(*mortar==0)){
68  if(ctrl[0]<*iit+4)ctrl[0]=*iit+4;
69  if(ctrl[1]<*iit+8)ctrl[1]=*iit+8;
70  ctrl[3]+=1;
71  }
72 
73  i0=ctrl[0];ir=ctrl[1];ip=ctrl[2];ic=ctrl[3];il=ctrl[4];ig=ctrl[5];
74  ia=ctrl[7];df=ctrl[10];dc=ctrl[11];db=ctrl[12];da=ctrl[13];dd=ctrl[16];
75  ran=ctrl[18];can=ctrl[19];rap=ctrl[22];
76  ea=ctrl[23];cae=ctrl[24];ral=ctrl[25];
77 
78  /* check for forced divergence (due to divergence of a user material
79  routine */
80 
81  if(qa[2]>0.){idivergence=1;}else{idivergence=0;}
82 
83  if(*ithermal!=2){
84  if(qa[0]>ea*qam[0]){
85  if(*iit<=ip){c1[0]=ran;}
86  else{c1[0]=rap;}
87  c2[0]=can;
88  }
89  else{
90  c1[0]=ea;
91  c2[0]=cae;
92  }
93  if(ram1[0]<ram2[0]){ram2[0]=ram1[0];}
94  }
95  if(*ithermal>1){
96  if(qa[1]>ea*qam[1]){
97  if(*iit<=ip){c1[1]=ran;}
98  else{c1[1]=rap;}
99  c2[1]=can;
100  }
101  else{
102  c1[1]=ea;
103  c2[1]=cae;
104  }
105  if(ram1[1]<ram2[1]){ram2[1]=ram1[1];}
106  }
107 
108  iconvergence=0;
109 
110  /* mechanical */
111 
112  if(*ithermal<2){
113  if((*iit>1)&&(ram[0]<=c1[0]*qam[0])&&(*iflagact==0)&&
114 // if((*iit>1)&&(ram[0]<=c1[0]*qam[0])&&
115  ((cam[0]<=c2[0]*uam[0])||
116  (((ram[0]*cam[0]<c2[0]*uam[0]*ram2[0])||(ram[0]<=ral*qam[0])||
117  (qa[0]<=ea*qam[0]))&&(*ntg==0))||
118  (cam[0]<1.e-8))) iconvergence=1;
119  }
120 
121  /* thermal */
122 
123  if(*ithermal==2){
124  if((ram[1]<=c1[1]*qam[1])&&
125  (cam[2]<*deltmx)&&
126  ((cam[1]<=c2[1]*uam[1])||
127  (((ram[1]*cam[1]<c2[1]*uam[1]*ram2[1])||(ram[1]<=ral*qam[1])||
128  (qa[1]<=ea*qam[1]))&&(*ntg==0))||
129  (cam[1]<1.e-8)))iconvergence=1;
130  }
131 
132  /* thermomechanical */
133 
134  if(*ithermal==3){
135 // if(((ram[0]<=c1[0]*qam[0])&&
136  if(((*iit>1)&&(ram[0]<=c1[0]*qam[0])&&
137  ((cam[0]<=c2[0]*uam[0])||
138  (((ram[0]*cam[0]<c2[0]*uam[0]*ram2[0])||(ram[0]<=ral*qam[0])||
139  (qa[0]<=ea*qam[0]))&&(*ntg==0))||
140  (cam[0]<1.e-8)))&&
141  ((ram[1]<=c1[1]*qam[1])&&
142  (cam[2]<*deltmx)&&
143  ((cam[1]<=c2[1]*uam[1])||
144  (((ram[1]*cam[1]<c2[1]*uam[1]*ram2[1])||(ram[1]<=ral*qam[1])||
145  (qa[1]<=ea*qam[1]))&&(*ntg==0))||
146  (cam[1]<1.e-8))))iconvergence=1;
147  }
148 
149  /* reset iflagact */
150 
151  *iflagact=0;
152 
153  /* increment convergence reached */
154 
155  if((iconvergence==1)&&(idivergence==0)){
156 // *ttime=*ttime+*dtime;
157 
158  /* cutting the insignificant digits from ttime */
159 
160 // *ttime=*ttime+1.;
161 // *ttime=*ttime-1.;
162  FORTRAN(writesummary,(istep,iinc,icutb,iit,ttime,time,dtime));
163  if(*uncoupled){
164  if(*ithermal==2){
165  *iitterm=*iit;
166  *ithermal=1;
167  for(k=0;k<*nk;++k){t1[k]=vold[mt*k];}
168 // *ttime=*ttime-*dtime;
169  *iit=1;
170  (ctrl[0])*=4;
171  printf(" thermal convergence\n\n");
172  return;
173  }else{
174  *ithermal=3;
175  *iit=*iitterm;
176  (ctrl[0])/=4;
177  }
178  }
179 
180  *icntrl=1;
181  *icutb=0;
182  *theta=*theta+*dtheta;
183 
184  /* defining a mean "velocity" for static calculations: is used to
185  extrapolate the present results for next increment */
186 
187  if(*nmethod != 4){
188  for(i=0;i<*nk;i++){
189  for(j=1;j<mt;j++){
190  veold[mt*i+j]=(vold[mt*i+j]-vini[mt*i+j])/(*dtime);
191  }
192  }
193  }
194 
195  /* check whether next increment size must be decreased */
196 
197  if((*iit>il)&&(*idrct==0)){
198  if(*mortar==0){
199  *dtheta=*dthetaref*db;
200  *dthetaref=*dtheta;
201  printf(" convergence; the increment size is decreased to %e\n\n",*dtheta**tper);
202  if(*dtheta<*tmin){
203  printf("\n *ERROR: increment size smaller than minimum\n");
204  printf(" best solution and residuals are in the frd file\n\n");
205  NNEW(fn,double,mt**nk);
206  NNEW(inum,ITG,*nk);for(k=0;k<*nk;k++) inum[k]=1;
207  FORTRAN(storeresidual,(nactdof,b,fn,filab,ithermal,
208  nk,sti,stn,ipkon,inum,kon,lakon,ne,mi,orab,
209  ielorien,co,itg,ntg,vold,ielmat,thicke,ielprop,prop));
210  ++*kode;
211 
212  (*ttime)+=(*time);
213  frd(co,nk,kon,ipkon,lakon,ne,vold,stn,inum,nmethod,
214  kode,filab,een,t1act,fn,ttime,epn,ielmat,matname,enern,
215  xstaten,nstate_,istep,iinc,ithermal,qfn,mode,noddiam,
216  trab,inotr,ntrans,orab,ielorien,norien,description,
217  ipneigh,neigh,mi,sti,vr,vi,stnr,stni,vmax,stnmax,
218  &ngraph,veold,ener,ne,cs,set,nset,istartset,iendset,
219  ialset,eenmax,fnr,fni,emn,thicke,jobnamec,output,qfx,
220  cdn,mortar,cdnr,cdni,nmat);
221 
222  FORTRAN(stop,());
223  }
224  }
225  else{
226  printf("convergence\n\n");}
227  }
228 
229  /* check whether next increment size can be increased */
230 
231  else if(*iit<=ig){
232  if((*istab==1)&&(*idrct==0)){
233  *dtheta=*dthetaref*dd;
234  *dthetaref=*dtheta;
235  printf(" convergence; the increment size is increased to %e\n\n",*dtheta**tper);
236  }
237  else{
238  *istab=1;
239  printf(" convergence\n\n");
240  *dtheta=*dthetaref;
241  }
242  }
243  else{
244  *istab=0;
245  printf(" convergence\n\n");
246  *dtheta=*dthetaref;
247  }
248 
249  /* check whether new increment size exceeds maximum increment
250  size allowed (by the user) */
251 
252  if((*dtheta>*tmax)&&(*idrct==0)){
253  *dtheta=*tmax;
254  *dthetaref=*dtheta;
255  printf(" the increment size exceeds thetamax and is decreased to %e\n\n",*dtheta**tper);
256  }
257 
258  /* if itp=1 the increment just finished ends at a time point */
259 
260  if((*itpamp>0)&&(*idrct==0)){
261  if(*itp==1){
262  *jprint=*jout;
263  }else{
264  *jprint=*jout+1;
265  }
266  if(namta[3**itpamp-1]<0){
267  reftime=*ttime+*time+*dtheta**tper;
268  }else{
269  reftime=*time+*dtheta**tper;
270  }
271  istart=namta[3**itpamp-3];
272  iend=namta[3**itpamp-2];
273  FORTRAN(identamta,(amta,&reftime,&istart,&iend,&id));
274  if(id<istart){
275  inew=istart;
276  }else{
277  inew=id+1;
278  }
279 
280  /* inew: smallest time point exceeding time+dtheta*tper
281  inext: smallest time point exceeding time */
282 
283  if(*inext<inew){
284  if(namta[3**itpamp-1]<0){
285  *dtheta=(amta[2**inext-2]-*ttime-*time)/(*tper);
286  }else{
287  *dtheta=(amta[2**inext-2]-*time)/(*tper);
288  }
289  (*inext)++;
290  *itp=1;
291  printf(" the increment size exceeds a time point and is decreased to %e\n\n",*dtheta**tper);
292  }else{*itp=0;}
293  }
294 
295  /* check whether new time point exceeds end of step */
296 
297  if(*dtheta>=1.-*theta){
298  if(*dtheta>1.-*theta){iexceed=1;}else{iexceed=0;}
299 // if((*mortar==1)&&(1.-*theta>0.01)){
300 // *dtheta=0.999-*theta;
301 // if((*mortar==1)&&(1.-*theta>0.5)){
302 // *dtheta=0.900-*theta;
303 // }else{
304  *dtheta=1.-*theta;
305 // }
306  *dthetaref=*dtheta;
307  if(iexceed==1)
308  printf(" the increment size exceeds the remainder of the step and is decreased to %e\n\n",*dtheta**tper);
309 // if(*dtheta<=1.e-6){
310 // (*ttime)+=(*dtheta**tper);
311 // *dtime=0.;
312 // }
313  }
314  }
315  else{
316 
317  /* no convergence */
318 
319  /* check for the amount of iterations */
320 
321  if((*iit>ic)&&(*mortar==0)){
322  printf("\n *ERROR: too many iterations needed\n");
323  printf(" best solution and residuals are in the frd file\n\n");
324 
325  FORTRAN(writesummarydiv,(istep,iinc,icutb,iit,ttime,time,dtime));
326 
327  NNEW(fn,double,mt**nk);
328  NNEW(inum,ITG,*nk);for(k=0;k<*nk;k++) inum[k]=1;
329  FORTRAN(storeresidual,(nactdof,b,fn,filab,ithermal,nk,sti,stn,
330  ipkon,inum,kon,lakon,ne,mi,orab,ielorien,co,itg,ntg,vold,
331  ielmat,thicke,ielprop,prop));
332  ++*kode;
333 
334  (*ttime)+=(*time);
335  frd(co,nk,kon,ipkon,lakon,ne,vold,stn,inum,nmethod,
336  kode,filab,een,t1act,fn,ttime,epn,ielmat,matname,enern,
337  xstaten,nstate_,istep,iinc,ithermal,qfn,mode,noddiam,
338  trab,inotr,ntrans,orab,ielorien,norien,description,
339  ipneigh,neigh,mi,sti,vr,vi,stnr,stni,vmax,stnmax,
340  &ngraph,veold,ener,ne,cs,set,nset,istartset,iendset,
341  ialset,eenmax,fnr,fni,emn,thicke,jobnamec,output,qfx,cdn,
342  mortar,cdnr,cdni,nmat);
343 
344  FORTRAN(stop,());
345  }
346 
347  /* check for diverging residuals */
348 
349  if((*iit>=i0)||(fabs(ram[0])>1.e20)||(fabs(cam[0])>1.e20)||
350  (fabs(ram[1])>1.e20)||(fabs(cam[1])>1.e20)||
351  (cam[2]>*deltmx)||(qa[2]>0.)){
352  if((*ithermal!=2)&&(*mortar==0)){
353  if((ram1[0]>ram2[0])&&(ram[0]>ram2[0])&&(ram[0]>c1[0]*qam[0]))
354  idivergence=1;
355  }
356 
357 /* if((*ithermal!=2)&&(*mortar==1)){
358  if((ram[0]>ram[6])&&(ram1[0]>ram[6])){
359  printf("divergence allowed: residual force not converging\n");
360  if((ram1[0]>ram2[0])&&(ram[0]>ram2[0])&&(ram[0]>c1[0]*qam[0]))
361  idivergence=1;
362  }
363  if(ram[5]<0.5){
364  printf("divergence allowed: number of contact elements stabilized\n");
365  if((ram1[0]>ram2[0])&&(ram[0]>ram2[0])&&(ram[0]>c1[0]*qam[0]))
366  idivergence=1;
367  }
368  if(ram[5]>=ram1[3]){
369  if(((ram[4]>0.97*ram1[2])&&(ram[4]<1.03*ram1[2]))&&
370  ((ram[4]>0.97*ram2[2])&&(ram[4]<1.03*ram2[2]))){
371  printf("divergence allowed: repetitive pattern detected\n");
372  if((ram1[0]>ram2[0])&&(ram[0]>ram2[0])&&(ram[0]>c1[0]*qam[0]))
373  idivergence=1;
374  if(((ram[4]>0.99*ram1[2])&&(ram[4]<1.01*ram1[2]))&&
375  ((ram[4]>0.99*ram2[2])&&(ram[4]<1.01*ram2[2])&&(ram[0]>c1[0]*qam[0]))){
376  printf("repetitive pattern within 1 per cent -> divergence\n");
377  idivergence=1;
378  }
379  if((ram[4]>(1-1.e-3)*ram1[2])&&(ram[4]<(1+1.e-3)*ram1[2])&&
380  (ram[4]>(1-1.e-3)*ram2[2])&&(ram[4]<(1+1.e-3)*ram2[2])&&
381  (ram[5]==ram1[3])&&(ram[5]==ram2[3])){
382  printf("infinite loop -> divergence\n");
383  idivergence=1;
384  }
385  }
386  }
387  }*/
388 
389  if((*ithermal!=2)&&(*mortar==1)){
390 
391  if(ram[0]>1.e9){
392  printf("divergence allowed: residual force too large\n");
393  if((ram1[0]>ram2[0])&&(ram[0]>ram2[0])&&(ram[0]>c1[0]*qam[0]))
394  idivergence=1;
395  }
396 
397  /* number of contact elements does not change */
398 
399  if(((ITG)ram[6]==0)&&((ITG)ram1[6]==0)){
400  printf("divergence allowed: number of contact elements stabilized\n");
401  if((ram1[0]>ram2[0])&&(ram[0]>ram2[0])&&(ram[0]>c1[0]*qam[0]))
402  idivergence=1;
403  }
404 
405  /* rate of number of contact elements is increasing */
406 
407  if(((ITG)ram[6]>=(ITG)ram1[6])&&((ITG)ram[6]>=(ITG)ram2[6])){
408 
409  if(((ram[4]>0.98*ram1[4])&&(ram[4]<1.02*ram1[4]))&&
410  ((ram[4]>0.98*ram2[4])&&(ram[4]<1.02*ram2[4]))){
411  printf("divergence allowed: repetitive pattern detected\n");
412  if((ram1[0]>ram2[0])&&(ram[0]>ram2[0])&&(ram[0]>c1[0]*qam[0]))
413  idivergence=1;
414  }
415 
416  /* if(((ram[4]>0.99*ram1[4])&&(ram[4]<1.01*ram1[4]))&&
417  ((ram[4]>0.99*ram2[4])&&(ram[4]<1.01*ram2[4]))&&
418  (ram[0]>c1[0]*qam[0])){
419  printf("repetitive pattern within 1 %: divergence\n");
420  idivergence=1;
421  }
422 
423  if(((ram[4]>(1.-1.e-3)*ram1[4])&&(ram[4]<(1.+1.e-3)*ram1[4]))&&
424  ((ram[4]>(1.-1.e-3)*ram2[4])&&(ram[4]<(1.+1.e-3)*ram2[4]))&&
425  ((ITG)ram[6]==(ITG)ram1[6])&&((ITG)ram[6]==(ITG)ram2[6])){
426  printf("infinite loop -> divergence\n");
427  idivergence=1;
428  }*/
429  }
430 
431  /* if(((ITG)ram1[7]==1)&&((ITG)ram2[7]!=-1)){
432  printf("divergence if ram>ram1>ram2: contact elements not stabilizing\n");
433  if((ram1[0]>ram2[0])&&(ram[0]>ram2[0])&&(ram[0]>c1[0]*qam[0]))
434  idivergence=1;
435  }*/
436  }
437 
438 
439  /* for thermal calculations the maximum temperature change
440  is checked as well */
441 
442  if(*ithermal>1){
443  if((ram1[1]>ram2[1])&&(ram[1]>ram2[1])&&(ram[1]>c1[1]*qam[1]))
444  idivergence=1;
445  if(cam[2]>*deltmx) idivergence=2;
446  }
447  if(idivergence>0){
448  if(*idrct==1) {
449 
450  /* fixed time increments */
451 
452  printf("\n *ERROR: solution seems to diverge; please try \n");
453  printf(" automatic incrementation; program stops\n");
454  printf(" best solution and residuals are in the frd file\n\n");
455 
456  FORTRAN(writesummarydiv,(istep,iinc,icutb,iit,ttime,time,
457  dtime));
458 
459  NNEW(fn,double,mt**nk);
460  NNEW(inum,ITG,*nk);for(k=0;k<*nk;k++) inum[k]=1;
461  FORTRAN(storeresidual,(nactdof,b,fn,filab,ithermal,nk,
462  sti,stn,ipkon,inum,kon,lakon,ne,mi,orab,
463  ielorien,co,itg,ntg,vold,ielmat,thicke,ielprop,prop));
464  ++*kode;
465 
466  (*ttime)+=(*time);
467  frd(co,nk,kon,ipkon,lakon,ne,vold,stn,inum,nmethod,
468  kode,filab,een,t1act,fn,ttime,epn,ielmat,matname,enern,
469  xstaten,nstate_,istep,iinc,ithermal,qfn,mode,noddiam,
470  trab,inotr,ntrans,orab,ielorien,norien,description,
471  ipneigh,neigh,mi,sti,vr,vi,stnr,stni,vmax,stnmax,
472  &ngraph,veold,ener,ne,cs,set,nset,istartset,iendset,
473  ialset,eenmax,fnr,fni,emn,thicke,jobnamec,output,qfx,cdn,
474  mortar,cdnr,cdni,nmat);
475 
476  FORTRAN(stop,());
477  }
478  else {
479 
480  /* variable time increments */
481 
482  if(qa[2]>0.){
483  *dtheta=*dtheta*qa[2];
484  printf("increment size decrease requested by a material user routine (through pnewdt)\n\n");
485  }else{
486  if(idivergence==1){
487  *dtheta=*dtheta*df;
488  }else{
489  *dtheta=*dtheta**deltmx/cam[2]*da;
490  }
491  }
492  *dthetaref=*dtheta;
493  printf(" divergence; the increment size is decreased to %e\n",*dtheta**tper);
494  printf(" the increment is reattempted\n\n");
495 
496  FORTRAN(writesummarydiv,(istep,iinc,icutb,iit,ttime,time,
497  dtime));
498 
499  *istab=0;
500  if(*itp==1){
501  *itp=0;
502  (*inext)--;
503  }
504 
505  /* check whether new increment size is smaller than minimum */
506 
507  if(*dtheta<*tmin){
508  printf("\n *ERROR: increment size smaller than minimum\n");
509  printf(" best solution and residuals are in the frd file\n\n");
510  NNEW(fn,double,mt**nk);
511  NNEW(inum,ITG,*nk);for(k=0;k<*nk;k++) inum[k]=1;
512  FORTRAN(storeresidual,(nactdof,b,fn,filab,ithermal,
513  nk,sti,stn,ipkon,inum,kon,lakon,ne,mi,orab,
514  ielorien,co,itg,ntg,vold,ielmat,thicke,ielprop,prop));
515  ++*kode;
516 
517  (*ttime)+=(*time);
518  frd(co,nk,kon,ipkon,lakon,ne,vold,stn,inum,nmethod,
519  kode,filab,een,t1act,fn,ttime,epn,ielmat,matname,enern,
520  xstaten,nstate_,istep,iinc,ithermal,qfn,mode,noddiam,
521  trab,inotr,ntrans,orab,ielorien,norien,description,
522  ipneigh,neigh,mi,sti,vr,vi,stnr,stni,vmax,stnmax,
523  &ngraph,veold,ener,ne,cs,set,nset,istartset,iendset,
524  ialset,eenmax,fnr,fni,emn,thicke,jobnamec,output,qfx,cdn,
525  mortar,cdnr,cdni,nmat);
526 
527  FORTRAN(stop,());
528  }
529  *icntrl=1;
530  (*icutb)++;
531 
532  /* check whether too many cutbacks */
533 
534  if(*icutb>ia){
535  printf("\n *ERROR: too many cutbacks\n");
536  printf(" best solution and residuals are in the frd file\n\n");
537  NNEW(fn,double,mt**nk);
538  NNEW(inum,ITG,*nk);for(k=0;k<*nk;k++) inum[k]=1;
539  FORTRAN(storeresidual,(nactdof,b,fn,filab,ithermal,
540  nk,sti,stn,ipkon,inum,kon,lakon,ne,mi,orab,
541  ielorien,co,itg,ntg,vold,ielmat,thicke,ielprop,prop));
542  ++*kode;
543 
544  (*ttime)+=(*time);
545  frd(co,nk,kon,ipkon,lakon,ne,vold,stn,inum,nmethod,
546  kode,filab,een,t1act,fn,ttime,epn,ielmat,matname,enern,
547  xstaten,nstate_,istep,iinc,ithermal,qfn,mode,noddiam,
548  trab,inotr,ntrans,orab,ielorien,norien,description,
549  ipneigh,neigh,mi,sti,vr,vi,stnr,stni,vmax,stnmax,
550  &ngraph,veold,ener,ne,cs,set,nset,istartset,iendset,
551  ialset,eenmax,fnr,fni,emn,thicke,jobnamec,output,qfx,cdn,
552  mortar,cdnr,cdni,nmat);
553 
554  FORTRAN(stop,());
555  }
556  if(*uncoupled){
557  if(*ithermal==1){
558  (ctrl[0])/=4;
559  }
560  *ithermal=3;
561  }
562 
563  /* default value for qa[2] */
564 
565  qa[2]=-1.;
566 
567  return;
568  }
569  }
570  }
571 
572  /* check for too slow convergence */
573 
574  if(*iit>=ir){
575  if(*ithermal!=2){
576  iest1=(ITG)ceil(*iit+log(ran*qam[0]/(ram[0]))/
577  log(ram[0]/(ram1[0])));
578  }
579  if(*ithermal>1){
580  iest2=(ITG)ceil(*iit+log(ran*qam[1]/(ram[1]))/
581  log(ram[1]/(ram1[1])));
582  }
583  if(iest1>iest2){iest=iest1;}else{iest=iest2;}
584  if((iest>0)&&(*mortar==0)){
585  printf(" estimated number of iterations till convergence = %" ITGFORMAT "\n",
586  iest);
587  }
588  if((((iest>ic)||(*iit==ic))&&(*mortar==0))||((*mortar==1)&&(*iit==60))){
589 
590  if(*idrct!=1){
591  *dtheta=*dtheta*dc;
592  *dthetaref=*dtheta;
593  printf(" too slow convergence; the increment size is decreased to %e\n",*dtheta**tper);
594  printf(" the increment is reattempted\n\n");
595 
596  FORTRAN(writesummarydiv,(istep,iinc,icutb,iit,ttime,
597  time,dtime));
598 
599  *istab=0;
600 
601  /* check whether new increment size is smaller than minimum */
602 
603  if(*dtheta<*tmin){
604  printf("\n *ERROR: increment size smaller than minimum\n");
605  printf(" best solution and residuals are in the frd file\n\n");
606  NNEW(fn,double,mt**nk);
607  NNEW(inum,ITG,*nk);for(k=0;k<*nk;k++) inum[k]=1;
608  FORTRAN(storeresidual,(nactdof,b,fn,filab,ithermal,
609  nk,sti,stn,ipkon,inum,kon,lakon,ne,mi,orab,
610  ielorien,co,itg,ntg,vold,ielmat,thicke,ielprop,prop));
611  ++*kode;
612 
613  (*ttime)+=(*time);
614  frd(co,nk,kon,ipkon,lakon,ne,vold,stn,inum,nmethod,
615  kode,filab,een,t1act,fn,ttime,epn,ielmat,matname,enern,
616  xstaten,nstate_,istep,iinc,ithermal,qfn,mode,noddiam,
617  trab,inotr,ntrans,orab,ielorien,norien,description,
618  ipneigh,neigh,mi,sti,vr,vi,stnr,stni,vmax,stnmax,
619  &ngraph,veold,ener,ne,cs,set,nset,istartset,iendset,
620  ialset,eenmax,fnr,fni,emn,thicke,jobnamec,output,qfx,cdn,
621  mortar,cdnr,cdni,nmat);
622 
623  FORTRAN(stop,());
624  }
625  *icntrl=1;
626  (*icutb)++;
627  if(*icutb>ia){
628  printf("\n *ERROR: too many cutbacks\n");
629  printf(" best solution and residuals are in the frd file\n\n");
630  NNEW(fn,double,mt**nk);
631  NNEW(inum,ITG,*nk);for(k=0;k<*nk;k++) inum[k]=1;
632  FORTRAN(storeresidual,(nactdof,b,fn,filab,ithermal,
633  nk,sti,stn,ipkon,inum,kon,lakon,ne,mi,orab,
634  ielorien,co,itg,ntg,vold,ielmat,thicke,ielprop,prop));
635  ++*kode;
636 
637  (*ttime)+=(*time);
638  frd(co,nk,kon,ipkon,lakon,ne,vold,stn,inum,nmethod,
639  kode,filab,een,t1act,fn,ttime,epn,ielmat,matname,enern,
640  xstaten,nstate_,istep,iinc,ithermal,qfn,mode,noddiam,
641  trab,inotr,ntrans,orab,ielorien,norien,description,
642  ipneigh,neigh,mi,sti,vr,vi,stnr,stni,vmax,stnmax,
643  &ngraph,veold,ener,ne,cs,set,nset,istartset,iendset,
644  ialset,eenmax,fnr,fni,emn,thicke,jobnamec,output,qfx,cdn,
645  mortar,cdnr,cdni,nmat);
646 
647  FORTRAN(stop,());
648  }
649  if(*uncoupled){
650  if(*ithermal==1){
651  (ctrl[0])/=4;
652  }
653  *ithermal=3;
654  }
655  return;
656  }
657  }
658  }
659 
660  printf(" no convergence\n\n");
661 
662  (*iit)++;
663 
664  }
665 
666  /* default value for qa[2] */
667 
668  /* qa[2]=-1;*/
669 
670  return;
671 }
#define ITGFORMAT
Definition: CalculiX.h:52
void frd(double *co, ITG *nk, ITG *kon, ITG *ipkon, char *lakon, ITG *ne0, double *v, double *stn, ITG *inum, ITG *nmethod, ITG *kode, char *filab, double *een, double *t1, double *fn, double *time, double *epn, ITG *ielmat, char *matname, double *enern, double *xstaten, ITG *nstate_, ITG *istep, ITG *iinc, ITG *ithermal, double *qfn, ITG *mode, ITG *noddiam, double *trab, ITG *inotr, ITG *ntrans, double *orab, ITG *ielorien, ITG *norien, char *description, ITG *ipneigh, ITG *neigh, ITG *mi, double *stx, double *vr, double *vi, double *stnr, double *stni, double *vmax, double *stnmax, ITG *ngraph, double *veold, double *ener, ITG *ne, double *cs, char *set, ITG *nset, ITG *istartset, ITG *iendset, ITG *ialset, double *eenmax, double *fnr, double *fni, double *emn, double *thicke, char *jobnamec, char *output, double *qfx, double *cdn, ITG *mortar, double *cdnr, double *cdni, ITG *nmat)
Definition: frd.c:27
void FORTRAN(addimdnodecload,(ITG *nodeforc, ITG *i, ITG *imdnode, ITG *nmdnode, double *xforc, ITG *ikmpc, ITG *ilmpc, ITG *ipompc, ITG *nodempc, ITG *nmpc, ITG *imddof, ITG *nmddof, ITG *nactdof, ITG *mi, ITG *imdmpc, ITG *nmdmpc, ITG *imdboun, ITG *nmdboun, ITG *ikboun, ITG *nboun, ITG *ilboun, ITG *ithermal))
subroutine df(x, u, uprime, rpar, nev)
Definition: subspace.f:132
subroutine writesummary(istep, j, icutb, l, ttime, time, dtime)
Definition: writesummary.f:19
subroutine storeresidual(nactdof, b, fn, filab, ithermal, nk, sti, stn, ipkon, inum, kon, lakon, ne, mi, orab, ielorien, co, itg, ntg, vold, ielmat, thicke, ielprop, prop)
Definition: storeresidual.f:19
subroutine stop()
Definition: stop.f:19
subroutine writesummarydiv(istep, j, icutb, l, ttime, time, dtime)
Definition: writesummarydiv.f:19
subroutine identamta(amta, reftime, istart, iend, id)
Definition: identamta.f:25
#define ITG
Definition: CalculiX.h:51
#define NNEW(a, b, c)
Definition: CalculiX.h:39
void checkconvnet ( ITG icutb,
ITG iin,
double *  qamt,
double *  qamf,
double *  qamp,
double *  ram1t,
double *  ram1f,
double *  ram1p,
double *  ram2t,
double *  ram2f,
double *  ram2p,
double *  ramt,
double *  ramf,
double *  ramp,
ITG icntrl,
double *  dtheta,
double *  ctrl,
double *  uama,
double *  ram1a,
double *  ram2a,
double *  rama,
double *  vamt,
double *  vamf,
double *  vamp,
double *  vama 
)

Definition at line 32 of file checkconvnet.c.

39  {
40 
41  ITG i0,ir,ip,ic,il,ig,ia,idivergence;
42 
43  double c1t,c1f,c1p,c1a;
44  double df,dc,db,dd,ran,can,rap,ea,cae,ral;
45 
46  i0=ctrl[0];ir=ctrl[1];ip=ctrl[2];ic=ctrl[3];il=ctrl[4];ig=ctrl[5];ia=ctrl[7];
47  df=ctrl[10];dc=ctrl[11];db=ctrl[12];dd=ctrl[16];
48  ran=ctrl[18];can=ctrl[19];rap=ctrl[22];
49  ea=ctrl[23];cae=ctrl[24];ral=ctrl[25];
50 
51  /* temperature */
52 
53  if(*iin<=ip){c1t=0.0001*ran;}
54  else{c1t=0.0001*rap;}
55 
56  /* mass flow */
57 
58  if(*iin<=ip){c1f=0.0001*ran;}
59  else{c1f=0.0001*rap;}
60 
61  /* pressure */
62 
63  if(*iin<=ip){c1p=0.0001*ran;}
64  else{c1p=0.0001*rap;}
65 
66  /* geometry */
67 
68  if(*iin<=ip){c1a=0.0001*ran;}
69  else{c1a=0.0001*rap;}
70 
71  if(*cam1t<*cam2t) {*cam2t=*cam1t;}
72  if(*cam1f<*cam2f) {*cam2f=*cam1f;}
73  if(*cam1p<*cam2p) {*cam2p=*cam1p;}
74  if(*cam1a<*cam2a) {*cam2a=*cam1a;}
75 
76  /* check for convergence or divergence;
77  each call of radflowload.c corresponds to a thermomechanical
78  iteration, let's call the iterations within radflowload.c
79  subiterations;
80  the convergence check consists of a comparison of the change in
81  the latest subiteration with
82  - the largest change in the present thermomechanical iteration
83  - the largest value in the present thermomechanical iteration */
84 
85 /* if(((*camt<=c1t**uamt)||(*camt<1.e-8**vamt))&&
86  ((*camf<=c1f**uamf)||(*camf<1.e-8**vamf))&&
87  ((*camp<=c1p**uamp)||(*camp<1.e-8**vamp))&&
88  ((*cama<=c1a**uama)||(*cama<1.e-8**vama))&&*/
89  if(((*camt<=c1t**uamt)||(*camt<c1t**vamt))&&
90  ((*camf<=c1f**uamf)||(*camf<c1f**vamf))&&
91  ((*camp<=c1p**uamp)||(*camp<c1p**vamp))&&
92  ((*cama<=c1a**uama)||(*cama<c1a**vama))&&
93  (*iin>3)){
94 
95  /* increment convergence reached */
96 
97  printf(" flow network: convergence in gas iteration %" ITGFORMAT " \n\n",*iin);
98  *icntrl=1;
99  *icutb=0;
100  }
101 
102  else {
103 
104  idivergence=0;
105 
106  /* divergence based on temperatures */
107 
108  if((*iin>=20*i0)||(fabs(*camt)>1.e20)){
109  if((*cam1t>=*cam2t)&&(*camt>=*cam2t)&&(*camt>c1t**uamt)){
110  idivergence=1;
111  }
112  }
113 
114  /* divergence based on the mass flux */
115 
116  if((*iin>=20*i0)||(fabs(*camf)>1.e20)){
117  if((*cam1f>=*cam2f)&&(*camf>=*cam2f)&&(*camf>c1f**uamf)){
118  idivergence=1;
119  }
120  }
121 
122  /* divergence based on pressures */
123 
124  if((*iin>=20*i0)||(fabs(*camp)>1.e20)){
125  if((*cam1p>=*cam2p)&&(*camp>=*cam2p)&&(*camp>c1p**uamp)){
126  idivergence=1;
127  }
128  }
129 
130  /* divergence based on geometry */
131 
132  if((*iin>=20*i0)||(fabs(*cama)>1.e20)){
133  if((*cam1a>=*cam2a)&&(*cama>=*cam2a)&&(*cama>c1a**uama)){
134  idivergence=1;
135  }
136  }
137 
138  /* divergence based on the number of iterations */
139 
140  if(*iin>20*ic) idivergence=1;
141 
142  /* divergence based on singular matrix or negative pressures */
143 
144  if(*iin==0) idivergence=1;
145 
146  if(idivergence==1){
147  *dtheta=*dtheta*df;
148  printf("\n divergence; the increment size is decreased to %e\n",*dtheta);
149  printf(" the increment is reattempted\n\n");
150  *iin=0;
151  (*icutb)++;
152  if(*icutb>ia){
153  printf("\n *ERROR: too many cutbacks\n");
154  FORTRAN(stop,());
155  }
156  }else{
157  printf(" no convergence\n\n");
158  }
159  }
160  return;
161 }
#define ITGFORMAT
Definition: CalculiX.h:52
void FORTRAN(addimdnodecload,(ITG *nodeforc, ITG *i, ITG *imdnode, ITG *nmdnode, double *xforc, ITG *ikmpc, ITG *ilmpc, ITG *ipompc, ITG *nodempc, ITG *nmpc, ITG *imddof, ITG *nmddof, ITG *nactdof, ITG *mi, ITG *imdmpc, ITG *nmdmpc, ITG *imdboun, ITG *nmdboun, ITG *ikboun, ITG *nboun, ITG *ilboun, ITG *ithermal))
subroutine df(x, u, uprime, rpar, nev)
Definition: subspace.f:132
subroutine stop()
Definition: stop.f:19
#define ITG
Definition: CalculiX.h:51
void checkinclength ( double *  time,
double *  ttime,
double *  theta,
double *  dtheta,
ITG idrct,
double *  tper,
double *  tmax,
double *  tmin,
double *  ctrl,
double *  amta,
ITG namta,
ITG itpamp,
ITG inext,
double *  dthetaref,
ITG itp,
ITG jprint,
ITG jout 
)

Definition at line 32 of file checkinclength.c.

35  {
36 
37  ITG id,istart,iend,inew,ireduceincrement;
38  double reftime;
39 
40  ITG i0,ir,ip,ic,il,ig,ia;
41  double df,dc,db,dd,ran,can,rap,ea,cae,ral,da;
42  i0=ctrl[0];ir=ctrl[1];ip=ctrl[2];ic=ctrl[3];il=ctrl[4];ig=ctrl[5];ia=ctrl[7];
43  df=ctrl[10];dc=ctrl[11];db=ctrl[12];da=ctrl[13];dd=ctrl[16];
44  ran=ctrl[18];can=ctrl[19];rap=ctrl[22];
45  ea=ctrl[23];cae=ctrl[24];ral=ctrl[25];
46 
47  /* check whether the new increment size is not too big */
48 
49  if(*dtheta>*tmax){
50  *dtheta=*tmax;
51 // printf(" the increment size exceeds thetamax and is decreased to %e\n\n",*dtheta**tper);
52  }
53 
54  /* if itp=1 the increment just finished ends at a time point */
55 
56  if((*itpamp>0)&&(*idrct==0)){
57  if(namta[3**itpamp-1]<0){
58  reftime=*ttime+*time+(*dtheta)**tper;
59  }else{
60  reftime=*time+(*dtheta)**tper;
61  }
62  istart=namta[3**itpamp-3];
63  iend=namta[3**itpamp-2];
64  FORTRAN(identamta,(amta,&reftime,&istart,&iend,&id));
65  if(id<istart){
66  inew=istart;
67  }else{
68  inew=id+1;
69  }
70 // printf("istart=%" ITGFORMAT ",iend=%" ITGFORMAT ",inext=%" ITGFORMAT ",inew=%" ITGFORMAT "\n",istart,iend,*inext,inew);
71 
72  /* inew: smallest time point exceeding time+dtheta*tper
73  inext: smallest time point exceeding time */
74 
75  /* the check with *tmin
76  was introduced to circumvent the following problem: if the new data point is
77  smaller than the next data point, but the distance is very small, the next *dheta
78  calculated a few lines below may be zero due to the subtraction of two nearly equal
79  numbers; a zero *dtheta leads to a fatal error */
80 
81  ireduceincrement=0;
82  if(*inext<iend){
83  if(fabs((amta[2**inext-2]-reftime)/(*tper))<*tmin){
84  ireduceincrement=1;
85  }
86  }
87 
88  if((*inext<inew)||(ireduceincrement==1)){
89 // if((*inext<inew)||(fabs((amta[2**inext-2]-reftime)/(*tper))<*tmin)){
90  // if((*inext<inew)||(fabs((amta[2**inext-2]-reftime))<1.e-10)){
91 
92  if(namta[3**itpamp-1]<0){
93  *dtheta=(amta[2**inext-2]-*ttime-*time)/(*tper);
94  }else{
95  *dtheta=(amta[2**inext-2]-*time)/(*tper);
96  }
97  (*inext)++;
98  *itp=1;
99 // printf(" the increment size exceeds a time point and is decreased to %e\n\n",*dtheta**tper);
100  }else{*itp=0;}
101  }
102 
103  /* check whether the step length is not exceeded */
104 
105  if(*dtheta>1.-*theta){
106  *dtheta=1.-*theta;
107  *dthetaref=*dtheta;
108  printf(" the increment size exceeds the remainder of the step and is decreased to %e\n\n",*dtheta**tper);
109 // if(*dtheta<=1.e-6){(*ttime)+=(*dtheta**tper);}
110  }
111 
112  return;
113 }
void FORTRAN(addimdnodecload,(ITG *nodeforc, ITG *i, ITG *imdnode, ITG *nmdnode, double *xforc, ITG *ikmpc, ITG *ilmpc, ITG *ipompc, ITG *nodempc, ITG *nmpc, ITG *imddof, ITG *nmddof, ITG *nactdof, ITG *mi, ITG *imdmpc, ITG *nmdmpc, ITG *imdboun, ITG *nmdboun, ITG *ikboun, ITG *nboun, ITG *ilboun, ITG *ithermal))
subroutine df(x, u, uprime, rpar, nev)
Definition: subspace.f:132
subroutine identamta(amta, reftime, istart, iend, id)
Definition: identamta.f:25
#define ITG
Definition: CalculiX.h:51
void compfluid ( double **  cop,
ITG nk,
ITG **  ipkonp,
ITG **  konp,
char **  lakonp,
char **  sideface,
ITG ifreestream,
ITG nfreestream,
ITG isolidsurf,
ITG neighsolidsurf,
ITG nsolidsurf,
ITG **  iponoel,
ITG **  inoel,
ITG nshcon,
double *  shcon,
ITG nrhcon,
double *  rhcon,
double **  voldp,
ITG ntmat_,
ITG nodeboun,
ITG ndirboun,
ITG nboun,
ITG **  ipompcp,
ITG **  nodempcp,
ITG nmpc,
ITG **  ikmpcp,
ITG **  ilmpcp,
ITG ithermal,
ITG ikboun,
ITG ilboun,
ITG turbulent,
ITG isolver,
ITG iexpl,
double *  vcontu,
double *  ttime,
double *  time,
double *  dtime,
ITG nodeforc,
ITG ndirforc,
double *  xforc,
ITG nforc,
ITG nelemload,
char *  sideload,
double *  xload,
ITG nload,
double *  xbody,
ITG ipobody,
ITG nbody,
ITG ielmat,
char *  matname,
ITG mi,
ITG ncmat_,
double *  physcon,
ITG istep,
ITG iinc,
ITG ibody,
double *  xloadold,
double *  xboun,
double **  coefmpcp,
ITG nmethod,
double *  xforcold,
double *  xforcact,
ITG iamforc,
ITG iamload,
double *  xbodyold,
double *  xbodyact,
double *  t1old,
double *  t1,
double *  t1act,
ITG iamt1,
double *  amta,
ITG namta,
ITG nam,
double *  ampli,
double *  xbounold,
double *  xbounact,
ITG iamboun,
ITG itg,
ITG ntg,
char *  amname,
double *  t0,
ITG **  nelemface,
ITG nface,
double *  cocon,
ITG ncocon,
double *  xloadact,
double *  tper,
ITG jmax,
ITG jout,
char *  set,
ITG nset,
ITG istartset,
ITG iendset,