resultsstr.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 resultsstr.c:

Go to the source code of this file.

Functions
void	resultsstr (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 *nener, char *orname, ITG *network, ITG *neapar, ITG *nebpar)
void *	resultsmechmtstr (ITG *i)

Variables
static char *	lakon1
static char *	matname1
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	num_cpus
static ITG	mt1
static ITG *	nk1
static ITG *	ne01
static ITG *	mortar1
static ITG *	ielprop1
static ITG *	kscale1
static ITG *	neapar1
static ITG *	nebpar1
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 *	thicke1
static double *	emeini1
static double *	prop1
static double *	pslavsurf1
static double *	pmastsurf1
static double *	clearini1

Function Documentation

resultsmechmtstr()

void* resultsmechmtstr

(

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;
    
    nea=neapar1[*i]+1;
    neb=nebpar1[*i]+1;
    
// 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;
}

resultsstr()

void resultsstr	(	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 *	nener,
		char *	orname,
		ITG *	network,
		ITG *	neapar,
		ITG *	nebpar
	)

                                                         {

    ITG intpointvarm,calcul_fn,calcul_f,calcul_qa,calcul_cauchy,ikin,
        intpointvart,mt=mi[1]+1,i,j;

    /*

     calculating the stress integration point values

     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];

    /* setting the output variables */

    calcul_fn=0;
    calcul_f=0;
    calcul_qa=0;
    calcul_cauchy=1;

    qa[0]=0.e0;
    qa[1]=0.e0;
    intpointvarm=1;
    ikin=0;

    /* 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;neapar1=neapar;
    nebpar1=nebpar;

    /* 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 *)resultsmechmtstr, (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 */

        for(j=0;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];}
        }
        }
    }

    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);
    }

    /* 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;

}

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

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

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

iout1

ITG * iout1

static

iperturb1

ITG * iperturb1

static

ipkon1

ITG * ipkon1

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

ne01

ITG * ne01

static

ne1

ITG * ne1

static

neapar1

ITG * neapar1

static

nebpar1

ITG * nebpar1

static

nelcon1

ITG * nelcon1

static

nener1

ITG * nener1

static

nk1

ITG * nk1

static

nmethod1

ITG * nmethod1

static

norien1

ITG * norien1

static

nplicon1

ITG * nplicon1

static

nplkcon1

ITG * nplkcon1

static

npmat1_

ITG * npmat1_

static

nrhcon1

ITG * nrhcon1

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

reltime1

double * reltime1

static

rhcon1

double * rhcon1

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

xstate1

double * xstate1

static

xstateini1

double * xstateini1

static

xstiff1

double * xstiff1

static