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

Go to the source code of this file.

Functions
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 *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 *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, double *energyini, double *energy, ITG *iponoel, ITG *inoel, char *orname, ITG *network, ITG *ipobody, double *xbody, ITG *ibody)
void *	resultsemmt (ITG *i)
void *	resultsthermemmt (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 *	iperturb1
static ITG *	iout1
static ITG *	nmethod1
static ITG *	nplkcon1
static ITG *	npmat1_
static ITG *	mi1
static ITG *	ncmat1_
static ITG *	nstate1_
static ITG *	ielprop1
static ITG *	inoel1
static ITG *	istep1
static ITG *	iinc1
static ITG	calcul_fn1
static ITG	calcul_qa1
static ITG *	nplicon1
static ITG *	iponoel1
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 *	nshcon1
static ITG *	nelemload1
static ITG *	nload1
static ITG	mortar1
static ITG *	istartset1
static ITG *	iendset1
static ITG *	ialset1
static ITG *	iactive1
static ITG *	network1
static ITG *	ipobody1
static ITG *	ibody1
static double *	co1
static double *	v1
static double *	elcon1
static double *	rhcon1
static double *	alcon1
static double *	orab1
static double *	t01
static double *	fn1 =NULL
static double *	qa1 =NULL
static double *	vold1
static double *	dtime1
static double *	time1
static double *	prop1
static double *	ttime1
static double *	plkcon1
static double *	xstateini1
static double *	xstiff1
static double *	xstate1
static double *	sti1
static double *	springarea1
static double *	reltime1
static double *	coefmpc1
static double *	vini1
static double *	cocon1
static double *	qfx1
static double *	shcon1
static double *	xload1
static double *	plicon1
static double *	xloadold1
static double *	h01
static double *	pslavsurf1
static double *	pmastsurf1
static double *	clearini1
static double *	xbody1

Function Documentation

resultsemmt()

void* resultsemmt

(

ITG *

i

)

                         {

    ITG nea,neb,nedelta;

    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(resultsem,(co1,kon1,ipkon1,lakon1,v1,elcon1,nelcon1,ielmat1,
       ntmat1_,vini1,dtime1,matname1,mi1,ncmat1_,&nea,&neb,sti1,alcon1,
       nalcon1,h01,istartset1,iendset1,ialset1,iactive1,fn1));

    return NULL;
}

resultsinduction()

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 *	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 *	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,
		double *	energyini,
		double *	energy,
		ITG *	iponoel,
		ITG *	inoel,
		char *	orname,
		ITG *	network,
		ITG *	ipobody,
		double *	xbody,
		ITG *	ibody
	)

                                                          {
      
    /* variables for multithreading procedure */
    
    char *env,*envloc,*envsys;

    ITG intpointvarm,calcul_fn,calcul_f,calcul_qa,calcul_cauchy,nener,ikin,
        intpointvart,mt=mi[1]+1,i,j,*ithread=NULL,*islavsurf=NULL,
        sys_cpus,mortar=0,*islavact=NULL;

    double *pmastsurf=NULL,*clearini=NULL,*pslavsurf=NULL,*cdn=NULL;

    /*

     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 */
    
    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_em,(nk,v,ithermal,filab,iperturb,f,fn,
       nactdof,iout,qa,b,nodeboun,ndirboun,
       xboun,nboun,ipompc,nodempc,coefmpc,labmpc,nmpc,nmethod,cam,neq,
       veold,dtime,mi,vini,nprint,prlab,
       &intpointvarm,&calcul_fn,&calcul_f,&calcul_qa,&calcul_cauchy,&nener,
       &ikin,&intpointvart,xforc,nforc));

    /* electromagnetic calculation is linear: should not be taken
       into account in the convergence check (only thermal part
       is taken into account) */

    cam[0]=0.;

    /* 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)){

    co1=co;kon1=kon;ipkon1=ipkon;lakon1=lakon;v1=v;elcon1=elcon;
        nelcon1=nelcon;ielmat1=ielmat;ntmat1_=ntmat_;vini1=vini;dtime1=dtime;
        matname1=matname;mi1=mi;ncmat1_=ncmat_;sti1=sti;alcon1=alcon;
    nalcon1=nalcon;h01=h0;ne1=ne;istartset1=istartset;iendset1=iendset;
        ialset1=ialset;iactive1=iactive;fn1=fn;

    /* calculating the magnetic field */
    
    if(((*nmethod!=4)&&(*nmethod!=5))||(iperturb[0]>1)){
        printf(" Using up to %" ITGFORMAT " cpu(s) for the magnetic field 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 *)resultsemmt, (void *)&ithread[i]);
    }
    for(i=0; i<num_cpus; i++)  pthread_join(tid[i], NULL);
    SFREE(ithread);

    qa[0]=0.;
    }

    /* 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;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 *)resultsthermemmt, (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 thermal internal forces */

    FORTRAN(resultsforc_em,(nk,f,fn,nactdof,ipompc,nodempc,
        coefmpc,labmpc,nmpc,mi,fmpc,&calcul_fn,&calcul_f,inomat));

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

}

resultsthermemmt()

void* resultsthermemmt

(

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

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

elcon1

double * elcon1

static

fn1

double * fn1 =NULL

static

h01

double * h01

static

iactive1

ITG * iactive1

static

ialset1

ITG * ialset1

static

ibody1

ITG * ibody1

static

ielmat1

ITG * ielmat1

static

ielorien1

ITG * ielorien1

static

ielprop1

ITG * ielprop1

static

iendset1

ITG * iendset1

static

iinc1

ITG * iinc1

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

istartset1

ITG * istartset1

static

istep1

ITG * istep1

static

ithermal1

ITG * ithermal1

static

kon1

ITG* kon1

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

ne1

ITG * ne1

static

nelcon1

ITG * nelcon1

static

nelemload1

ITG * nelemload1

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

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

sti1

double * sti1

static

t01

double * t01

static

time1

double * time1

static

ttime1

double * ttime1

static

v1

double * v1

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