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

Include dependency graph for results.c:

Functions
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 cam, ITG neq, double veold, double accold, double bet, double gam, double dtime, double time, double ttime, double plicon, ITG nplicon, double plkcon, ITG nplkcon, double xstateini, double xstiff, double xstate, ITG npmat_, double epn, 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, double energyini, double energy, ITG kscale, ITG iponoel, ITG inoel, ITG nener, char orname, ITG network, ITG ipobody, double xbody, ITG *ibody)

void *	resultsmechmt (ITG *i)

void *	resultsthermmt (ITG *i)

Variables
static char *	lakon1

static char *	matname1

static char *	sideload1

static ITG *	kon1

static ITG *	ipkon1

static ITG *	ne1

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 *	iout1

static ITG *	nmethod1

static ITG *	nplicon1

static ITG *	nplkcon1

static ITG *	npmat1_

static ITG *	mi1

static ITG *	ielas1

static ITG *	icmd1

static ITG *	ncmat1_

static ITG *	nstate1_

static ITG *	istep1

static ITG *	iinc1

static ITG	calcul_fn1

static ITG	calcul_qa1

static ITG	calcul_cauchy1

static ITG *	nener1

static ITG	ikin1

static ITG *	nal =NULL

static ITG *	ipompc1

static ITG *	nodempc1

static ITG *	nmpc1

static ITG *	ncocon1

static ITG *	ikmpc1

static ITG *	ilmpc1

static ITG	num_cpus

static ITG	mt1

static ITG *	nk1

static ITG *	ne01

static ITG *	nshcon1

static ITG *	nelemload1

static ITG *	nload1

static ITG *	mortar1

static ITG *	ielprop1

static ITG *	kscale1

static ITG *	iponoel1

static ITG *	inoel1

static ITG *	network1

static ITG *	ipobody1

static ITG *	ibody1

static double *	co1

static double *	v1

static double *	stx1

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 *	eme1

static double *	fn1 =NULL

static double *	qa1 =NULL

static double *	vold1

static double *	veold1

static double *	dtime1

static double *	time1

static double *	ttime1

static double *	plicon1

static double *	plkcon1

static double *	xstateini1

static double *	xstiff1

static double *	xstate1

static double *	stiini1

static double *	vini1

static double *	ener1

static double *	eei1

static double *	enerini1

static double *	springarea1

static double *	reltime1

static double *	coefmpc1

static double *	cocon1

static double *	qfx1

static double *	thicke1

static double *	emeini1

static double *	shcon1

static double *	xload1

static double *	prop1

static double *	xloadold1

static double *	pslavsurf1

static double *	pmastsurf1

static double *	clearini1

static double *	xbody1

Function Documentation

◆ results()

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 *	cam,
		ITG *	neq,
		double *	veold,
		double *	accold,
		double *	bet,
		double *	gam,
		double *	dtime,
		double *	time,
		double *	ttime,
		double *	plicon,
		ITG *	nplicon,
		double *	plkcon,
		ITG *	nplkcon,
		double *	xstateini,
		double *	xstiff,
		double *	xstate,
		ITG *	npmat_,
		double *	epn,
		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,
		double *	energyini,
		double *	energy,
		ITG *	kscale,
		ITG *	iponoel,
		ITG *	inoel,
		ITG *	nener,
		char *	orname,
		ITG *	network,
		ITG *	ipobody,
		double *	xbody,
		ITG *	ibody
	)

                                                                        {
 
     ITG intpointvarm,calcul_fn,calcul_f,calcul_qa,calcul_cauchy,ikin,
         intpointvart,mt=mi[1]+1,i,j;
 
     /*
 
      calculating integration point values (strains, stresses,
      heat fluxes, material tangent matrices and nodal forces)
 
      storing the nodal and integration point results in the
      .dat file
 
      iout=-2: v is assumed to be known and is used to
               calculate strains, stresses..., no result output
               corresponds to iout=-1 with in addition the
               calculation of the internal energy density
      iout=-1: v is assumed to be known and is used to
               calculate strains, stresses..., no result output;
               is used to take changes in SPC's and MPC's at the
               start of a new increment or iteration into account
      iout=0: v is calculated from the system solution
              and strains, stresses.. are calculated, no result output
      iout=1:  v is calculated from the system solution and strains,
               stresses.. are calculated, requested results output
      iout=2: v is assumed to be known and is used to 
              calculate strains, stresses..., requested results output */
       
     /* 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;
     }
 
     /* 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_RESULTS");
     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];
     
     /* 1. nodewise storage of the primary variables
        2. determination which derived variables have to be calculated */
 
     FORTRAN(resultsini,(nk,v,ithermal,filab,iperturb,f,fn,
        nactdof,iout,qa,vold,b,nodeboun,ndirboun,
        xboun,nboun,ipompc,nodempc,coefmpc,labmpc,nmpc,nmethod,cam,neq,
        veold,accold,bet,gam,dtime,mi,vini,nprint,prlab,
        &intpointvarm,&calcul_fn,&calcul_f,&calcul_qa,&calcul_cauchy,nener,
        &ikin,&intpointvart,xforc,nforc));
 
    /* next statement allows for storing the displacements in each
       iteration: for debugging purposes */
 
     if((strcmp1(&filab[3],"I")==0)&&(*iout==0)){
     FORTRAN(frditeration,(co,nk,kon,ipkon,lakon,ne,v,
         ttime,ielmat,matname,mi,istep,iinc,ithermal));
     }
 
     /* calculating the stresses and material tangent at the 
        integration points; calculating the internal forces */
 
     if(((ithermal[0]<=1)||(ithermal[0]>=3))&&(intpointvarm==1)){
 
     NNEW(fn1,double,num_cpus*mt**nk);
     NNEW(qa1,double,num_cpus*4);
     NNEW(nal,ITG,num_cpus);
 
     co1=co;kon1=kon;ipkon1=ipkon;lakon1=lakon;ne1=ne;v1=v;
         stx1=stx;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;eme1=eme;iperturb1=iperturb;iout1=iout;
         vold1=vold;nmethod1=nmethod;veold1=veold;dtime1=dtime;
         time1=time;ttime1=ttime;plicon1=plicon;nplicon1=nplicon;
         plkcon1=plkcon;nplkcon1=nplkcon;xstateini1=xstateini;
         xstiff1=xstiff;xstate1=xstate;npmat1_=npmat_;matname1=matname;
         mi1=mi;ielas1=ielas;icmd1=icmd;ncmat1_=ncmat_;nstate1_=nstate_;
         stiini1=stiini;vini1=vini;ener1=ener;eei1=eei;enerini1=enerini;
         istep1=istep;iinc1=iinc;springarea1=springarea;reltime1=reltime;
         calcul_fn1=calcul_fn;calcul_qa1=calcul_qa;calcul_cauchy1=calcul_cauchy;
         nener1=nener;ikin1=ikin;mt1=mt;nk1=nk;ne01=ne0;thicke1=thicke;
         emeini1=emeini;pslavsurf1=pslavsurf;clearini1=clearini;
         pmastsurf1=pmastsurf;mortar1=mortar;ielprop1=ielprop;prop1=prop;
         kscale1=kscale;
 
     /* calculating the stresses */
     
     if(((*nmethod!=4)&&(*nmethod!=5))||(iperturb[0]>1)){
         printf(" Using up to %" ITGFORMAT " cpu(s) for the stress calculation.\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 *)resultsmechmt, (void *)&ithread[i]);
     }
     for(i=0; i<num_cpus; i++)  pthread_join(tid[i], NULL);
     
     for(i=0;i<mt**nk;i++){
         fn[i]=fn1[i];
     }
     for(i=0;i<mt**nk;i++){
         for(j=1;j<num_cpus;j++){
         fn[i]+=fn1[i+j*mt**nk];
         }
     }
     SFREE(fn1);SFREE(ithread);
     
         /* determine the internal force */
 
     qa[0]=qa1[0];
     for(j=1;j<num_cpus;j++){
         qa[0]+=qa1[j*4];
     }
 
         /* determine the decrease of the time increment in case
            the material routine diverged */
 
     qa[2]=qa1[2];
         for(j=1;j<num_cpus;j++){
         if(qa1[2+j*4]>0.){
         if(qa[2]<0.){
             qa[2]=qa1[2+j*4];
         }else{
             if(qa1[2+j*4]<qa[2]){qa[2]=qa1[2+j*4];}
         }
         }
     }
 
         /* maximum change in creep strain increment in the
            present time increment */
 
     qa[3]=qa1[3];
         for(j=1;j<num_cpus;j++){
         if(qa1[3+j*4]>0.){
         if(qa[3]<0.){
             qa[3]=qa1[3+j*4];
         }else{
             if(qa1[3+j*4]>qa[3]){qa[3]=qa1[3+j*4];}
         }
         }
     }
 
     SFREE(qa1);
     
     for(j=1;j<num_cpus;j++){
         nal[0]+=nal[j];
     }
 
     if(calcul_qa==1){
         if(nal[0]>0){
         qa[0]/=nal[0];
         }
     }
     SFREE(nal);
     }
 
     /* calculating the thermal flux and material tangent at the 
        integration points; calculating the internal point flux */
 
     if((ithermal[0]>=2)&&(intpointvart==1)){
 
     NNEW(fn1,double,num_cpus*mt**nk);
     NNEW(qa1,double,num_cpus*4);
     NNEW(nal,ITG,num_cpus);
 
     co1=co;kon1=kon;ipkon1=ipkon;lakon1=lakon;v1=v;
         elcon1=elcon;nelcon1=nelcon;rhcon1=rhcon;nrhcon1=nrhcon;
     ielmat1=ielmat;ielorien1=ielorien;norien1=norien;orab1=orab;
         ntmat1_=ntmat_;t01=t0;iperturb1=iperturb;iout1=iout;vold1=vold;
         ipompc1=ipompc;nodempc1=nodempc;coefmpc1=coefmpc;nmpc1=nmpc;
         dtime1=dtime;time1=time;ttime1=ttime;plkcon1=plkcon;
         nplkcon1=nplkcon;xstateini1=xstateini;xstiff1=xstiff;
         xstate1=xstate;npmat1_=npmat_;matname1=matname;mi1=mi;
         ncmat1_=ncmat_;nstate1_=nstate_;cocon1=cocon;ncocon1=ncocon;
         qfx1=qfx;ikmpc1=ikmpc;ilmpc1=ilmpc;istep1=istep;iinc1=iinc;
         springarea1=springarea;calcul_fn1=calcul_fn;calcul_qa1=calcul_qa;
         mt1=mt;nk1=nk;shcon1=shcon;nshcon1=nshcon;ithermal1=ithermal;
         nelemload1=nelemload;nload1=nload;nmethod1=nmethod;reltime1=reltime;
         sideload1=sideload;xload1=xload;xloadold1=xloadold;
         pslavsurf1=pslavsurf;pmastsurf1=pmastsurf;mortar1=mortar;
         clearini1=clearini;plicon1=plicon;nplicon1=nplicon;ne1=ne;
         ielprop1=ielprop,prop1=prop;iponoel1=iponoel;inoel1=inoel;
     network1=network;ipobody1=ipobody;ibody1=ibody;xbody1=xbody;
 
     /* calculating the heat flux */
     
     printf(" Using up to %" ITGFORMAT " cpu(s) for the heat flux calculation.\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 *)resultsthermmt, (void *)&ithread[i]);
     }
     for(i=0; i<num_cpus; i++)  pthread_join(tid[i], NULL);
     
     for(i=0;i<*nk;i++){
         fn[mt*i]=fn1[mt*i];
     }
     for(i=0;i<*nk;i++){
         for(j=1;j<num_cpus;j++){
         fn[mt*i]+=fn1[mt*i+j*mt**nk];
         }
     }
     SFREE(fn1);SFREE(ithread);
     
         /* determine the internal concentrated heat flux */
 
     qa[1]=qa1[1];
     for(j=1;j<num_cpus;j++){
         qa[1]+=qa1[1+j*4];
     }
     
     SFREE(qa1);
     
     for(j=1;j<num_cpus;j++){
         nal[0]+=nal[j];
     }
 
     if(calcul_qa==1){
         if(nal[0]>0){
         qa[1]/=nal[0];
         }
     }
     SFREE(nal);
     }
 
     /* calculating the matrix system internal force vector */
 
     FORTRAN(resultsforc,(nk,f,fn,nactdof,ipompc,nodempc,
         coefmpc,labmpc,nmpc,mi,fmpc,&calcul_fn,&calcul_f));
 
     /* storing results in the .dat file
        extrapolation of integration point values to the nodes
        interpolation of 3d results for 1d/2d elements */
 
     FORTRAN(resultsprint,(co,nk,kon,ipkon,lakon,ne,v,stn,inum,
        stx,ielorien,norien,orab,t1,ithermal,filab,een,iperturb,fn,
        nactdof,iout,vold,nodeboun,ndirboun,nboun,nmethod,ttime,xstate,
        epn,mi,
        nstate_,ener,enern,xstaten,eei,set,nset,istartset,iendset,
        ialset,nprint,prlab,prset,qfx,qfn,trab,inotr,ntrans,
        nelemload,nload,&ikin,ielmat,thicke,eme,emn,rhcon,nrhcon,shcon,
        nshcon,cocon,ncocon,ntmat_,sideload,icfd,inomat,pslavsurf,islavact,
        cdn,mortar,islavnode,nslavnode,ntie,islavsurf,time,ielprop,prop,
        veold,ne0,nmpc,ipompc,nodempc,labmpc,energyini,energy,orname,
        xload));
   
   return;
 
 }

◆ resultsmechmt()

void* resultsmechmt ( ITG * i )

                            {
 
     ITG indexfn,indexqa,indexnal,nea,neb,nedelta;
 
     indexfn=*i*mt1**nk1;
     indexqa=*i*4;
     indexnal=*i;
     
 // ceil -> floor
 
     nedelta=(ITG)floor(*ne1/(double)num_cpus);
     nea=*i*nedelta+1;
     neb=(*i+1)*nedelta;
 // next line! -> all parallel sections
     if((*i==num_cpus-1)&&(neb<*ne1)) neb=*ne1;
 
     FORTRAN(resultsmech,(co1,kon1,ipkon1,lakon1,ne1,v1,
           stx1,elcon1,nelcon1,rhcon1,nrhcon1,alcon1,nalcon1,alzero1,
           ielmat1,ielorien1,norien1,orab1,ntmat1_,t01,t11,ithermal1,prestr1,
           iprestr1,eme1,iperturb1,&fn1[indexfn],iout1,&qa1[indexqa],vold1,
           nmethod1,
           veold1,dtime1,time1,ttime1,plicon1,nplicon1,plkcon1,nplkcon1,
           xstateini1,xstiff1,xstate1,npmat1_,matname1,mi1,ielas1,icmd1,
           ncmat1_,nstate1_,stiini1,vini1,ener1,eei1,enerini1,istep1,iinc1,
           springarea1,reltime1,&calcul_fn1,&calcul_qa1,&calcul_cauchy1,nener1,
       &ikin1,&nal[indexnal],ne01,thicke1,emeini1,
       pslavsurf1,pmastsurf1,mortar1,clearini1,&nea,&neb,ielprop1,prop1,kscale1));
 
     return NULL;
 }

◆ resultsthermmt()

void* resultsthermmt ( ITG * i )

                             {
 
     ITG indexfn,indexqa,indexnal,nea,neb,nedelta;
 
     indexfn=*i*mt1**nk1;
     indexqa=*i*4;
     indexnal=*i;
     
     nedelta=(ITG)floor(*ne1/(double)num_cpus);
     nea=*i*nedelta+1;
     neb=(*i+1)*nedelta;
     if((*i==num_cpus-1)&&(neb<*ne1)) neb=*ne1;
 
     FORTRAN(resultstherm,(co1,kon1,ipkon1,lakon1,v1,
        elcon1,nelcon1,rhcon1,nrhcon1,ielmat1,ielorien1,norien1,orab1,
        ntmat1_,t01,iperturb1,&fn1[indexfn],shcon1,nshcon1,
        iout1,&qa1[indexqa],vold1,ipompc1,nodempc1,coefmpc1,nmpc1,
            dtime1,time1,ttime1,plkcon1,nplkcon1,xstateini1,xstiff1,xstate1,
            npmat1_,matname1,mi1,ncmat1_,nstate1_,cocon1,ncocon1,
            qfx1,ikmpc1,ilmpc1,istep1,iinc1,springarea1,
        &calcul_fn1,&calcul_qa1,&nal[indexnal],&nea,&neb,ithermal1,
        nelemload1,nload1,nmethod1,reltime1,sideload1,xload1,xloadold1,
        pslavsurf1,pmastsurf1,mortar1,clearini1,plicon1,nplicon1,ielprop1,
        prop1,iponoel1,inoel1,network1,ipobody1,xbody1,ibody1));
 
     return NULL;
 }

Variable Documentation

◆ alcon1

double * alcon1

static

◆ alzero1

double * alzero1

static

◆ calcul_cauchy1

ITG calcul_cauchy1

static

◆ calcul_fn1

ITG calcul_fn1

static

◆ calcul_qa1

ITG calcul_qa1

static

◆ clearini1

double * clearini1

static

◆ co1

double* co1

static

◆ cocon1

double * cocon1

static

◆ coefmpc1

double * coefmpc1

static

◆ dtime1

double * dtime1

static

◆ eei1

double * eei1

static

◆ elcon1

double * elcon1

static

◆ eme1

double * eme1

static

◆ emeini1

double * emeini1

static

◆ ener1

double * ener1

static

◆ enerini1

double * enerini1

static

◆ fn1

double * fn1 =NULL

static

◆ ibody1

ITG * ibody1

static

◆ icmd1

ITG * icmd1

static

◆ ielas1

ITG * ielas1

static

◆ ielmat1

ITG * ielmat1

static

◆ ielorien1

ITG * ielorien1

static

◆ ielprop1

ITG * ielprop1

static

◆ iinc1

ITG * iinc1

static

◆ ikin1

ITG ikin1

static

◆ ikmpc1

ITG * ikmpc1

static

◆ ilmpc1

ITG * ilmpc1

static

◆ inoel1

ITG * inoel1

static

◆ iout1

ITG * iout1

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

◆ istep1

ITG * istep1

static

◆ ithermal1

ITG * ithermal1

static

◆ kon1

ITG* kon1

static

◆ kscale1

ITG * kscale1

static

◆ lakon1

char* lakon1

static

◆ matname1

char * matname1

static

◆ mi1

ITG * mi1

static

◆ mortar1

ITG * mortar1

static

◆ mt1

ITG mt1

static

◆ nal

ITG * nal =NULL

static

◆ nalcon1

ITG * nalcon1

static

◆ ncmat1_

ITG * ncmat1_

static

◆ ncocon1

ITG * ncocon1

static

◆ ne01

ITG * ne01

static

◆ ne1

ITG * ne1

static

◆ nelcon1

ITG * nelcon1

static

◆ nelemload1

ITG * nelemload1

static

◆ nener1

ITG * nener1

static

◆ network1

ITG * network1

static

◆ nk1

ITG * nk1

static

◆ nload1

ITG * nload1

static

◆ nmethod1

ITG * nmethod1

static

◆ nmpc1

ITG * nmpc1

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

◆ ntmat1_

ITG * ntmat1_

static

◆ num_cpus

ITG num_cpus

static

◆ orab1

double * orab1

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

◆ qa1

double * qa1 =NULL

static

◆ qfx1

double * qfx1

static

◆ reltime1

double * reltime1

static

◆ rhcon1

double * rhcon1

static

◆ shcon1

double * shcon1

static

◆ sideload1

char * sideload1

static

◆ springarea1

double * springarea1

static

◆ stiini1

double * stiini1

static

◆ stx1

double * stx1

static

◆ t01

double * t01

static

◆ t11

double * t11

static

◆ thicke1

double * thicke1

static

◆ time1

double * time1

static

◆ ttime1

double * ttime1

static

◆ v1

double * v1

static

◆ veold1

double * veold1

static

◆ vini1

double * vini1

static

◆ vold1

double * vold1

static

◆ xbody1

double * xbody1

static

◆ xload1

double * xload1

static

◆ xloadold1

double * xloadold1

static

◆ xstate1

double * xstate1

static

◆ xstateini1

double * xstateini1

static

◆ xstiff1

double * xstiff1

static

Functions

Variables

Function Documentation

◆ results()

◆ resultsmechmt()

◆ resultsthermmt()

Variable Documentation

◆ alcon1

◆ alzero1

◆ calcul_cauchy1

◆ calcul_fn1

◆ calcul_qa1

◆ clearini1

◆ co1

◆ cocon1

◆ coefmpc1

◆ dtime1

◆ eei1

◆ elcon1

◆ eme1

◆ emeini1

◆ ener1

◆ enerini1

◆ fn1

◆ ibody1

◆ icmd1

◆ ielas1

◆ ielmat1

◆ ielorien1

◆ ielprop1

◆ iinc1

◆ ikin1

◆ ikmpc1

◆ ilmpc1

◆ inoel1

◆ iout1

◆ iperturb1

◆ ipkon1

◆ ipobody1

◆ ipompc1

◆ iponoel1

◆ iprestr1

◆ istep1

◆ ithermal1

◆ kon1

◆ kscale1

◆ lakon1

◆ matname1

◆ mi1

◆ mortar1

◆ mt1

◆ nal

◆ nalcon1

◆ ncmat1_

◆ ncocon1

◆ ne01

◆ ne1

◆ nelcon1

◆ nelemload1

◆ nener1

◆ network1

◆ nk1

◆ nload1

◆ nmethod1

◆ nmpc1

◆ nodempc1

◆ norien1

◆ nplicon1

◆ nplkcon1

◆ npmat1_

◆ nrhcon1

◆ nshcon1

◆ nstate1_

◆ ntmat1_

◆ num_cpus

◆ orab1

◆ plicon1

◆ plkcon1

◆ pmastsurf1

◆ prestr1