mafillsmmain.c File Reference

#include <unistd.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <pthread.h>
#include "CalculiX.h"

Include dependency graph for mafillsmmain.c:

Go to the source code of this file.

Functions
void	mafillsmmain (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 *fext, 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 *rhsi, ITG *intscheme, double *physcon, double *shcon, ITG *nshcon, double *cocon, ITG *ncocon, double *ttime, double *time, ITG *istep, ITG *iinc, 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, ITG *ne0, double *fnext, ITG *kscale, ITG *iponoel, ITG *inoel, ITG *network)
void *	mafillsmmt (ITG *i)

Variables
static char *	lakon1
static char *	sideload1
static char *	matname1
static char *	tieset1
static ITG *	nk1
static ITG *	kon1
static ITG *	ipkon1
static ITG *	ne1
static ITG *	nodeboun1
static ITG *	ndirboun1
static ITG *	nboun1
static ITG *	ipompc1
static ITG *	nodempc1
static ITG *	nmpc1
static ITG *	nodeforc1
static ITG *	ndirforc1
static ITG *	nforc1
static ITG *	nelemload1
static ITG *	nload1
static ITG *	ipobody1
static ITG *	nbody1
static ITG *	nactdof1
static ITG *	icol1
static ITG *	jq1
static ITG *	irow1
static ITG *	neq1
static ITG *	nzl1
static ITG *	nmethod1 =NULL
static ITG *	ikmpc1
static ITG *	ilmpc1
static ITG *	ikboun1
static ITG *	ilboun1
static ITG *	nelcon1
static ITG *	nrhcon1
static ITG *	nalcon1
static ITG *	ielmat1
static ITG *	ielorien1
static ITG *	norien1
static ITG *	ntmat1_
static ITG *	ithermal1
static ITG *	iprestr1
static ITG *	iperturb1
static ITG *	nzs1
static ITG *	iexpl1
static ITG *	nplicon1
static ITG *	nplkcon1
static ITG *	npmat1_
static ITG *	mi1
static ITG *	ncmat1_
static ITG *	mass1
static ITG *	stiffness1
static ITG *	buckling1
static ITG *	rhsi1
static ITG *	intscheme1
static ITG *	nshcon1
static ITG *	ncocon1
static ITG *	istep1
static ITG *	iinc1
static ITG *	coriolis1
static ITG *	ibody1
static ITG *	nstate1_
static ITG *	integerglob1
static ITG *	istartset1
static ITG *	iendset1
static ITG *	ialset1
static ITG *	ntie1
static ITG *	nasym1
static ITG *	mortar1
static ITG *	ielprop1
static ITG *	ne01
static ITG	num_cpus
static ITG *	kscale1
static ITG *	iponoel1
static ITG *	inoel1
static ITG *	network1
static double *	co1
static double *	xboun1
static double *	coefmpc1
static double *	xforc1
static double *	xload1
static double *	xbody1
static double *	cgr1
static double *	ad1 =NULL
static double *	au1 =NULL
static double *	fext1 =NULL
static double *	elcon1
static double *	rhcon1
static double *	alcon1
static double *	alzero1
static double *	orab1
static double *	t01
static double *	t11
static double *	prestr1
static double *	vold1
static double *	sti1
static double *	stx1
static double *	adb1 =NULL
static double *	aub1 =NULL
static double *	plicon1
static double *	plkcon1
static double *	xstiff1
static double *	dtime1
static double *	physcon1
static double *	shcon1
static double *	cocon1
static double *	ttime1
static double *	time1
static double *	xloadold1
static double *	reltime1
static double *	veold1
static double *	springarea1
static double *	xstateini1
static double *	xstate1
static double *	thicke1
static double *	doubleglob1
static double *	pslavsurf1
static double *	pmastsurf1
static double *	clearini1
static double *	prop1
static double *	fnext1 =NULL

Function Documentation

mafillsmmain()

void mafillsmmain	(	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 *	fext,
		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 *	rhsi,
		ITG *	intscheme,
		double *	physcon,
		double *	shcon,
		ITG *	nshcon,
		double *	cocon,
		ITG *	ncocon,
		double *	ttime,
		double *	time,
		ITG *	istep,
		ITG *	iinc,
		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,
		ITG *	ne0,
		double *	fnext,
		ITG *	kscale,
		ITG *	iponoel,
		ITG *	inoel,
		ITG *	network
	)

                            {

    ITG i,j,mt=mi[1]+1;
      
    /* variables for multithreading procedure */
    
    ITG sys_cpus,*ithread=NULL;
    char *env,*envloc,*envsys;
    
    num_cpus = 0;
    sys_cpus=0;

    /* explicit user declaration prevails */

    envsys=getenv("NUMBER_OF_CPUS");
    if(envsys){
    sys_cpus=atoi(envsys);
    if(sys_cpus<0) sys_cpus=0;
    }

//    sys_cpus=1;

    /* automatic detection of available number of processors */

    if(sys_cpus==0){
    sys_cpus = getSystemCPUs();
    if(sys_cpus<1) sys_cpus=1;
    }

    /* local declaration prevails, if strictly positive */

    envloc = getenv("CCX_NPROC_STIFFNESS");
    if(envloc){
    num_cpus=atoi(envloc);
    if(num_cpus<0){
        num_cpus=0;
    }else if(num_cpus>sys_cpus){
        num_cpus=sys_cpus;
    }
    
    }

    /* else global declaration, if any, applies */

    env = getenv("OMP_NUM_THREADS");
    if(num_cpus==0){
    if (env)
        num_cpus = atoi(env);
    if (num_cpus < 1) {
        num_cpus=1;
    }else if(num_cpus>sys_cpus){
        num_cpus=sys_cpus;
    }
    }

// next line is to be inserted in a similar way for all other paralell parts

    if(*ne<num_cpus) num_cpus=*ne;
    
    pthread_t tid[num_cpus];

    /* determine nzl */

    *nzl=0;
    for(i=neq[1];i>=1;i--){
    if(icol[i-1]>0){
        *nzl=i;
        break;
    }
    }

    /* allocating fields for mass and stiffness matrix */

//    if(*buckling!=1){
    NNEW(ad1,double,num_cpus*neq[1]);
    NNEW(au1,double,(long long)num_cpus*nzs[2]);
//    }

    if(*rhsi==1){
    NNEW(fext1,double,num_cpus*neq[1]);
    }

    if((mass[1]==1)||((mass[0]==1)||(*buckling==1))){
    NNEW(adb1,double,num_cpus*neq[1]);
    NNEW(aub1,double,(long long)num_cpus*nzs[1]);
    }

    if(*nmethod==4){
    NNEW(fnext1,double,num_cpus*mt**nk);
    }

    /* allocating memory for nmethod; if the Jacobian determinant
       in any of the elements is nonpositive, nmethod is set to
       zero */

    NNEW(nmethod1,ITG,num_cpus);
    for(j=0;j<num_cpus;j++){
    nmethod1[j]=*nmethod;
    }

    /* calculating the stiffness and/or mass matrix 
       (symmetric part) */

    co1=co;nk1=nk;kon1=kon;ipkon1=ipkon;lakon1=lakon;ne1=ne;
    nodeboun1=nodeboun;ndirboun1=ndirboun;xboun1=xboun;
    nboun1=nboun;ipompc1=ipompc;nodempc1=nodempc;coefmpc1=coefmpc;
    nmpc1=nmpc;nodeforc1=nodeforc;ndirforc1=ndirforc;xforc1=xforc;
    nforc1=nforc;nelemload1=nelemload;sideload1=sideload;xload1=xload;
    nload1=nload;xbody1=xbody;ipobody1=ipobody;nbody1=nbody;
    cgr1=cgr;nactdof1=nactdof;icol1=icol;jq1=jq;irow1=irow;neq1=neq;
    nzl1=nzl;ikmpc1=ikmpc;ilmpc1=ilmpc;ikboun1=ikboun;
    ilboun1=ilboun;elcon1=elcon;nelcon1=nelcon;rhcon1=rhcon;
    nrhcon1=nrhcon;alcon1=alcon;nalcon1=nalcon;alzero1=alzero;
    ielmat1=ielmat;ielorien1=ielorien;norien1=norien;orab1=orab;
    ntmat1_=ntmat_;t01=t0;t11=t1;ithermal1=ithermal;prestr1=prestr;
    iprestr1=iprestr;vold1=vold;iperturb1=iperturb;sti1=sti;nzs1=nzs;
    stx1=stx;iexpl1=iexpl;plicon1=plicon;nplicon1=nplicon;
    plkcon1=plkcon;nplkcon1=nplkcon;xstiff1=xstiff;npmat1_=npmat_;
    dtime1=dtime;matname1=matname;mi1=mi;ncmat1_=ncmat_;mass1=mass;
    stiffness1=stiffness;buckling1=buckling;rhsi1=rhsi;intscheme1=intscheme;
    physcon1=physcon;shcon1=shcon;nshcon1=nshcon;cocon1=cocon;
    ncocon1=ncocon;ttime1=ttime;time1=time;istep1=istep;iinc1=iinc;
    coriolis1=coriolis;ibody1=ibody;xloadold1=xloadold;reltime1=reltime;
    veold1=veold;springarea1=springarea;nstate1_=nstate_;xstateini1=xstateini;
    xstate1=xstate;thicke1=thicke;integerglob1=integerglob;
    doubleglob1=doubleglob;tieset1=tieset;istartset1=istartset;
    iendset1=iendset;ialset1=ialset;ntie1=ntie;nasym1=nasym;
    pslavsurf1=pslavsurf;pmastsurf1=pmastsurf;mortar1=mortar;
    clearini1=clearini;ielprop1=ielprop;prop1=prop;ne01=ne0;kscale1=kscale;
    iponoel1=iponoel;inoel1=inoel;network1=network;  

    /* calculating the stiffness/mass */
    
    printf(" Using up to %" ITGFORMAT " cpu(s) for the symmetric stiffness/mass contributions.\n\n", num_cpus);
    
    /* create threads and wait */
    
    NNEW(ithread,ITG,num_cpus);
    for(i=0; i<num_cpus; i++)  {
    ithread[i]=i;
    pthread_create(&tid[i], NULL, (void *)mafillsmmt, (void *)&ithread[i]);
    }
    for(i=0; i<num_cpus; i++)  pthread_join(tid[i], NULL);
    
    SFREE(ithread);

    /*      for(i=0;i<num_cpus;i++){
      for(k=i*neq[1];k<i*neq[1]+neq[1];++k){printf("fext=%" ITGFORMAT ",%f\n",k-i*neq[1],fext1[k]);}
      for(k=i*neq[1];k<i*neq[1]+neq[1];++k){printf("ad=%" ITGFORMAT ",%f\n",k-i*neq[1],ad1[k]);}
      for(k=i*nzs[2];k<i*nzs[2]+nzs[2];++k){printf("au=%" ITGFORMAT ",%f\n",k-i*nzs[2],au1[k]);}
      }*/

    /* copying and accumulating the stiffnes and/or mass matrix 
       for buckling the matrices have to be added*/

    if(*buckling!=1){

        /* no buckling */

    for(i=0;i<neq[1];i++){
        ad[i]=ad1[i];
    }
    }else{

        /* buckling */

    for(i=0;i<neq[1];i++){
        ad[i]+=ad1[i];
    }
    }

    for(i=0;i<neq[1];i++){
    for(j=1;j<num_cpus;j++){
        ad[i]+=ad1[i+j*neq[1]];
    }
    }
    SFREE(ad1);
    
    if(*buckling!=1){

        /* no buckling */

    for(i=0;i<nzs[2];i++){
        au[i]=au1[i];
    }
    }else{

        /* buckling */

    for(i=0;i<nzs[2];i++){
        au[i]+=au1[i];
    }
    }

    for(i=0;i<nzs[2];i++){
    for(j=1;j<num_cpus;j++){
        au[i]+=au1[i+(long long)j*nzs[2]];
    }
    }
    SFREE(au1);

    if(*rhsi==1){
    for(i=0;i<neq[1];i++){
        fext[i]=fext1[i];
    }
    for(i=0;i<neq[1];i++){
        for(j=1;j<num_cpus;j++){
        fext[i]+=fext1[i+j*neq[1]];
        }
    }
    SFREE(fext1);
    }

    /* the heat capacity matrix and mass matrix must be treated
       separately, since the mass matrix is no recalculated
       in each iteration, whereas the capacity matrix is */

    /* heat capacity matrix */

    if(mass[1]==1){
    for(i=neq[0];i<neq[1];i++){
        adb[i]=adb1[i];
    }
    for(i=neq[0];i<neq[1];i++){
        for(j=1;j<num_cpus;j++){
        adb[i]+=adb1[i+j*neq[1]];
        }
    }

    for(i=nzs[0];i<nzs[1];i++){
        aub[i]=aub1[i];
    }
    for(i=nzs[0];i<nzs[1];i++){
        for(j=1;j<num_cpus;j++){
        aub[i]+=aub1[i+(long long)j*nzs[1]];
        }
    }
    }

    /* mass matrix or buckling matrix */

    if((mass[0]==1)||(*buckling==1)){
    for(i=0;i<neq[0];i++){
        adb[i]=adb1[i];
    }
    for(i=0;i<neq[0];i++){
        for(j=1;j<num_cpus;j++){
        adb[i]+=adb1[i+j*neq[1]];
        }
    }

    for(i=0;i<nzs[0];i++){
        aub[i]=aub1[i];
    }
    for(i=0;i<nzs[0];i++){
        for(j=1;j<num_cpus;j++){
        aub[i]+=aub1[i+(long long)j*nzs[1]];
        }
    }
    }
    if((mass[0]==1)||(mass[1]==1)||(*buckling==1)){
    SFREE(adb1);SFREE(aub1);
    }

    if(*nmethod==4){
    for(i=0;i<mt**nk;i++){
        fnext[i]=fnext1[i];
    }
    for(i=0;i<mt**nk;i++){
        for(j=1;j<num_cpus;j++){
        fnext[i]+=fnext1[i+j*mt**nk];
        }
    }
    SFREE(fnext1);
    }

    for(j=0;j<num_cpus;j++){
    if(nmethod1[j]==0){
        *nmethod=0;
        break;
    }
    }
    SFREE(nmethod1);
      
    /*     for(k=0;k<neq[1];++k){printf("fext=%" ITGFORMAT ",%f\n",k,fext[k]);}
      for(k=0;k<neq[1];++k){printf("ad=%" ITGFORMAT ",%f\n",k,ad[k]);}
      for(k=0;k<nzs[1];++k){printf("au=%" ITGFORMAT ",%f\n",k,au[k]);}*/

    /* taking point forces into account in fext */

    FORTRAN(mafillsmforc,(nforc,ndirforc,nodeforc,xforc,nactdof,
              fext,nmpc,ipompc,nodempc,ikmpc,ilmpc,
                  coefmpc,mi,rhsi,fnext,nmethod));
  
  return;

}

mafillsmmt()

void* mafillsmmt

(

ITG *

i

)

                        {

    ITG indexad,indexfext,indexadb,nea,neb,nedelta,indexfnext;
    long long indexau,indexaub;

    indexad=0;
    indexau=0;
    indexfext=0;
    indexadb=0;
    indexaub=0;
    indexfnext=0;

//    if(*buckling1!=1){
    indexad=*i*neq1[1];
    indexau=(long long)*i*nzs1[2];
//    }
    if(*rhsi1==1){
    indexfext=*i*neq1[1];
    }
    if(mass1[1]==1){
    indexadb=*i*neq1[1];
    indexaub=(long long)*i*nzs1[1];
    }else if((mass1[0]==1)||(*buckling1==1)){
    indexadb=*i*neq1[0];
    indexaub=(long long)*i*nzs1[0];
    }
    if(nmethod1[0]==4){
    indexfnext=*i*(mi1[1]+1)**nk1;
    }
    

    if((*nasym1==0)||(*ithermal1>1)){

        /* symmetric mechanical calculations or
           thermal/thermomechanical calculations:
           include contact elements (symmetric
           thermal contributions are not covered by
           mafillsmas.f) */

    nedelta=(ITG)floor(*ne1/(double)num_cpus);
    nea=*i*nedelta+1;
    neb=(*i+1)*nedelta;
    if((*i==num_cpus-1)&&(neb<*ne1)) neb=*ne1;
    }else{

        /* asymmetric mechanical calculations:
           do not include contact elements */

    nedelta=(ITG)floor(*ne01/(double)num_cpus);
    nea=*i*nedelta+1;
    neb=(*i+1)*nedelta;
    if((*i==num_cpus-1)&&(neb<*ne01)) neb=*ne01;
    }


    FORTRAN(mafillsm,(co1,nk1,kon1,ipkon1,lakon1,ne1,nodeboun1,ndirboun1,
        xboun1,nboun1,
        ipompc1,nodempc1,coefmpc1,nmpc1,nodeforc1,ndirforc1,xforc1,
        nforc1,nelemload1,sideload1,xload1,nload1,xbody1,ipobody1,
        nbody1,cgr1,&ad1[indexad],&au1[indexau],&fext1[indexfext],
        nactdof1,icol1,jq1,irow1,neq1,nzl1,&nmethod1[*i],
        ikmpc1,ilmpc1,ikboun1,ilboun1,
        elcon1,nelcon1,rhcon1,nrhcon1,alcon1,nalcon1,alzero1,ielmat1,
        ielorien1,norien1,orab1,ntmat1_,
        t01,t11,ithermal1,prestr1,iprestr1,vold1,iperturb1,sti1,
        nzs1,stx1,&adb1[indexadb],&aub1[indexaub],iexpl1,plicon1,
            nplicon1,plkcon1,nplkcon1,
        xstiff1,npmat1_,dtime1,matname1,mi1,
            ncmat1_,mass1,stiffness1,buckling1,rhsi1,intscheme1,physcon1,
            shcon1,nshcon1,cocon1,ncocon1,ttime1,time1,istep1,iinc1,coriolis1,
        ibody1,xloadold1,reltime1,veold1,springarea1,nstate1_,
            xstateini1,xstate1,thicke1,integerglob1,doubleglob1,
        tieset1,istartset1,iendset1,ialset1,ntie1,nasym1,pslavsurf1,
        pmastsurf1,mortar1,clearini1,ielprop1,prop1,ne01,
        &fnext1[indexfnext],&nea,&neb,kscale1,iponoel1,inoel1,network1));

    return NULL;
}

Variable Documentation

ad1

double * ad1 =NULL

static

adb1

double * adb1 =NULL

static

alcon1

double * alcon1

static

alzero1

double * alzero1

static

au1

double * au1 =NULL

static

aub1

double * aub1 =NULL

static

buckling1

ITG * buckling1

static

cgr1

double * cgr1

static

clearini1

double * clearini1

static

co1

double* co1

static

cocon1

double * cocon1

static

coefmpc1

double * coefmpc1

static

coriolis1

ITG * coriolis1

static

doubleglob1

double * doubleglob1

static

dtime1

double * dtime1

static

elcon1

double * elcon1

static

fext1

double * fext1 =NULL

static

fnext1

double * fnext1 =NULL

static

ialset1

ITG * ialset1

static

ibody1

ITG * ibody1

static

icol1

ITG * icol1

static

ielmat1

ITG * ielmat1

static

ielorien1

ITG * ielorien1

static

ielprop1

ITG * ielprop1

static

iendset1

ITG * iendset1

static

iexpl1

ITG * iexpl1

static

iinc1

ITG * iinc1

static

ikboun1

ITG * ikboun1

static

ikmpc1

ITG * ikmpc1

static

ilboun1

ITG * ilboun1

static

ilmpc1

ITG * ilmpc1

static

inoel1

ITG * inoel1

static

integerglob1

ITG * integerglob1

static

intscheme1

ITG * intscheme1

static

iperturb1

ITG * iperturb1

static

ipkon1

ITG * ipkon1

static

ipobody1

ITG * ipobody1

static

ipompc1

ITG * ipompc1

static

iponoel1

ITG * iponoel1

static

iprestr1

ITG * iprestr1

static

irow1

ITG * irow1

static

istartset1

ITG * istartset1

static

istep1

ITG * istep1

static

ithermal1

ITG * ithermal1

static

jq1

ITG * jq1

static

kon1

ITG * kon1

static

kscale1

ITG * kscale1

static

lakon1

char* lakon1

static

mass1

ITG * mass1

static

matname1

char * matname1

static

mi1

ITG * mi1

static

mortar1

ITG * mortar1

static

nactdof1

ITG * nactdof1

static

nalcon1

ITG * nalcon1

static

nasym1

ITG * nasym1

static

nbody1

ITG * nbody1

static

nboun1

ITG * nboun1

static

ncmat1_

ITG * ncmat1_

static

ncocon1

ITG * ncocon1

static

ndirboun1

ITG * ndirboun1

static

ndirforc1

ITG * ndirforc1

static

ne01

ITG * ne01

static

ne1

ITG * ne1

static

nelcon1

ITG * nelcon1

static

nelemload1

ITG * nelemload1

static

neq1

ITG * neq1

static

network1

ITG * network1

static

nforc1

ITG * nforc1

static

nk1

ITG* nk1

static

nload1

ITG * nload1

static

nmethod1

ITG * nmethod1 =NULL

static

nmpc1

ITG * nmpc1

static

nodeboun1

ITG * nodeboun1

static

nodeforc1

ITG * nodeforc1

static

nodempc1

ITG * nodempc1

static

norien1

ITG * norien1

static

nplicon1

ITG * nplicon1

static

nplkcon1

ITG * nplkcon1

static

npmat1_

ITG * npmat1_

static

nrhcon1

ITG * nrhcon1

static

nshcon1

ITG * nshcon1

static

nstate1_

ITG * nstate1_

static

ntie1

ITG * ntie1

static

ntmat1_

ITG * ntmat1_

static

num_cpus

ITG num_cpus

static

nzl1

ITG * nzl1

static

nzs1

ITG * nzs1

static

orab1

double * orab1

static

physcon1

double * physcon1

static

plicon1

double * plicon1

static

plkcon1

double * plkcon1

static

pmastsurf1

double * pmastsurf1

static

prestr1

double * prestr1

static

prop1

double * prop1

static

pslavsurf1

double * pslavsurf1

static

reltime1

double * reltime1

static

rhcon1

double * rhcon1

static

rhsi1

ITG * rhsi1

static

shcon1

double * shcon1

static

sideload1

char * sideload1

static

springarea1

double * springarea1

static

sti1

double * sti1

static

stiffness1

ITG * stiffness1

static

stx1

double * stx1

static

t01

double * t01

static

t11

double * t11

static

thicke1

double * thicke1

static

tieset1

char * tieset1

static

time1

double * time1

static

ttime1

double * ttime1

static

veold1

double * veold1

static

vold1

double * vold1

static

xbody1

double * xbody1

static

xboun1

double * xboun1

static

xforc1

double * xforc1

static

xload1

double * xload1

static

xloadold1

double * xloadold1

static

xstate1

double * xstate1

static

xstateini1

double * xstateini1

static

xstiff1

double * xstiff1

static