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

Include dependency graph for results_se.c:

Functions
void	results_se (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, double df, double distmin, ITG ndesi, ITG nodedesi, double sti, ITG nkon, ITG jqs, ITG irows, ITG nactdofinv, ITG icoordinate, double dxstiff, ITG istartdesi, ITG ialdesi, double xdesi, ITG ieigenfrequency, double fint, ITG *ishapeenergy)

void *	resultsmechmt_se (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_cauchy1

static ITG	nener1

static ITG	ikin1

static ITG	num_cpus

static ITG	mt1

static ITG *	nk1

static ITG *	ne01

static ITG *	mortar1

static ITG *	ielprop1

static ITG	idesvar1

static ITG *	nodedesi1

static ITG *	nkon1

static ITG *	icoordinate1

static ITG *	ialdesi1

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

static double *	pslavsurf1

static double *	pmastsurf1

static double *	clearini1

static double *	dfn1

static double *	fn01

static double *	sti1

static double *	xdesi1

Function Documentation

◆ results_se()

void results_se	(	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,
		double *	df,
		double *	distmin,
		ITG *	ndesi,
		ITG *	nodedesi,
		double *	sti,
		ITG *	nkon,
		ITG *	jqs,
		ITG *	irows,
		ITG *	nactdofinv,
		ITG *	icoordinate,
		double *	dxstiff,
		ITG *	istartdesi,
		ITG *	ialdesi,
		double *	xdesi,
		ITG *	ieigenfrequency,
		double *	fint,
		ITG *	ishapeenergy
	)

                          {
 
     ITG intpointvarm,calcul_fn,calcul_f,calcul_qa,calcul_cauchy,nener,ikin,
         intpointvart,mt=mi[1]+1,i,j,idesvar,iorien,idir,im,
         nea,neb;
     
     double *dfn=NULL,*fn0=NULL,a[9],pgauss[3],rotvec[3],orabsav[7];
 
     /* calculating the sensitivity of the internal forces */
       
     /* 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));
 
     NNEW(fn0,double,mt**nkon);
     NNEW(dfn,double,mt**nk);
         
     if(((*nmethod!=4)&&(*nmethod!=5))||(iperturb[0]>1)){
     printf(" Using up to %" ITGFORMAT " cpu(s) for the sensitivity of the internal forces.\n\n", num_cpus);
     }
 
     /* nodal forces without perturbation */
 
     idesvar=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(fn01,double,num_cpus*mt**nkon);
     
     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_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;
     idesvar1=idesvar;nodedesi1=nodedesi;
     sti1=sti;nkon1=nkon;icoordinate1=icoordinate;
     dxstiff1=dxstiff;ialdesi1=ialdesi;xdesi1=xdesi;
     
     /* 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_se, (void *)&ithread[i]);
     }
     for(i=0; i<num_cpus; i++)  pthread_join(tid[i], NULL);
     
     /* Assembling fn0 and dfn */
     
     for(i=0;i<mt**nkon;i++){
         fn0[i]=fn01[i];
     }
     for(i=0;i<mt**nkon;i++){
         for(j=1;j<num_cpus;j++){
         fn0[i]+=fn01[i+j*mt**nkon];
         }
     }
     
     SFREE(fn01);
     SFREE(ithread); 
     }
     
     /* in case of nonlinear geometry calculate vector fint */
     
     if((iperturb[1]==1)&&(*ishapeenergy==1)){
        FORTRAN(createfint,(ne,ipkon,lakon,kon,nactdof,mi,fn0,fint));
     }
     
     /* loop over the design variables (perturbation) */
     
     for(idesvar=1;idesvar<=*ndesi;idesvar++){
     
     DMEMSET(dfn,0,mt**nk,0.);
        
         /* calculate a delta in the orientation
            in case the material orientation is the design variable */
     
     if(*icoordinate!=1){
         iorien=(idesvar-1)/3;
         
         /* save nominal orientation */
         
         memcpy(&orabsav[0],&orab[7*iorien],sizeof(double)*7);
         
         /* calculate the transformation matrix */
         
         FORTRAN(transformatrix,(&orab[7*iorien],pgauss,a));
         
         /* calculate the rotation vector from the transformation matrix */
         
         FORTRAN(rotationvector,(a,rotvec));
         idir=(idesvar-1)-iorien*3;
         
         /* add a small variation to the rotation vector component */
         
         rotvec[idir]+=*distmin;
         
         /* determine the new transformation matrix */
         
         FORTRAN(rotationvectorinv,(a,rotvec));
         
         /* determine two new points in the x-y plane */
         
         for(i=0;i<6;i++){orab[7*iorien+i]=a[i];}
     }
     
     /* calculating the stresses and material tangent at the 
        integration points; calculating the internal forces */
     
     if(((ithermal[0]<=1)||(ithermal[0]>=3))&&(intpointvarm==1)){
         nea=istartdesi[idesvar-1];
         neb=istartdesi[idesvar]-1;
         
         FORTRAN(resultsmech_se,(co,kon,ipkon,lakon,ne,v,
         stx,elcon,nelcon,rhcon,nrhcon,alcon,nalcon,alzero,
         ielmat,ielorien,norien,orab,ntmat1_,t0,t1,ithermal,prestr,
         iprestr,eme,iperturb,fn,iout,vold,nmethod,
             veold,dtime,time,ttime,plicon,nplicon,plkcon,nplkcon,
                 xstateini,xstiff,xstate,npmat1_,matname,mi,ielas,icmd,
                 ncmat1_,nstate1_,stiini,vini,ener,eei,enerini,istep,iinc,
                 springarea,reltime,&calcul_fn,&calcul_cauchy,&nener,
                 &ikin,ne0,thicke,emeini,
                 pslavsurf,pmastsurf,mortar,clearini,&nea,&neb,ielprop,prop,
                 dfn,&idesvar,nodedesi,
             fn0,sti,icoordinate,dxstiff,ialdesi,xdesi));
     }
     
     /* calculating the matrix system internal force vector
            for nonlinear geometrical calculations */
     
 //  if((iperturb[1]==1)&&(*ieigenfrequency!=1)){
     if(*ieigenfrequency!=1){
        FORTRAN(resultsforc_se,(nk,dfn,nactdofinv,ipompc,nodempc,
                 coefmpc,nmpc,mi,fmpc,&calcul_fn,&calcul_f,
                 &idesvar,df,jqs,irows,distmin));
        }
        
         /* restoring the nominal orientation (in case the design variables
            are the orientations */
     
     if(*icoordinate!=1){
         if(idesvar>0){
         memcpy(&orab[7*iorien],&orabsav[0],sizeof(double)*7);
         }
     }
     
     }   /* end loop over design variables */
     
     
     SFREE(fn0);SFREE(dfn);
     
     return;
     
 }

◆ resultsmechmt_se()

void* resultsmechmt_se ( ITG * i )

                               {
 
     ITG indexfn0,indexdfn,nea,neb,nedelta;
 
     if(idesvar1==0){
     indexfn0=*i*mt1**nkon1;
     indexdfn=0;
     }else{
     indexfn0=0;
     indexdfn=*i*mt1**nk1;
     }
     
 // 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_se,(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,iout1,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_cauchy1,&nener1,
           &ikin1,ne01,thicke1,emeini1,
           pslavsurf1,pmastsurf1,mortar1,clearini1,&nea,&neb,ielprop1,prop1,
           &dfn1[indexdfn],&idesvar1,nodedesi1,
       &fn01[indexfn0],sti1,icoordinate1,dxstiff1,ialdesi1,xdesi1));
 
     return NULL;
 }

Variable Documentation

◆ alcon1

double * alcon1

static

◆ alzero1

double * alzero1

static

◆ calcul_cauchy1

ITG calcul_cauchy1

static

◆ calcul_fn1

ITG calcul_fn1

static

◆ clearini1

double * clearini1

static

◆ co1

double* co1

static

◆ dfn1

double * dfn1

static

◆ dtime1

double * dtime1

static

◆ dxstiff1

double * dxstiff1

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

◆ fn01

double * fn01

static

◆ fn1

double * fn1 =NULL

static

◆ ialdesi1

ITG * ialdesi1

static

◆ icmd1

ITG * icmd1

static

◆ icoordinate1

ITG * icoordinate1

static

◆ idesvar1

ITG idesvar1

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

◆ lakon1

char* lakon1

static

◆ matname1

char * matname1

static

◆ mi1

ITG * mi1

static

◆ mortar1

ITG * mortar1

static

◆ mt1

ITG mt1

static

◆ nalcon1

ITG * nalcon1

static

◆ ncmat1_

ITG * ncmat1_

static

◆ ne01

ITG * ne01

static

◆ ne1

ITG * ne1

static

◆ nelcon1

ITG * nelcon1

static

◆ nener1

ITG nener1

static

◆ nk1

ITG * nk1

static

◆ nkon1

ITG * nkon1

static

◆ nmethod1

ITG * nmethod1

static

◆ nodedesi1

ITG * nodedesi1

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

◆ reltime1

double * reltime1

static

◆ rhcon1

double * rhcon1

static

◆ springarea1

double * springarea1

static

◆ sti1

double * sti1

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

◆ xdesi1

double * xdesi1

static

◆ xstate1

double * xstate1

static

◆ xstateini1

double * xstateini1

static

◆ xstiff1

double * xstiff1

static

Functions

Variables

Function Documentation

◆ results_se()

◆ resultsmechmt_se()

Variable Documentation

◆ alcon1

◆ alzero1

◆ calcul_cauchy1

◆ calcul_fn1

◆ clearini1

◆ co1

◆ dfn1

◆ dtime1

◆ dxstiff1

◆ eei1

◆ elcon1

◆ eme1

◆ emeini1

◆ ener1

◆ enerini1

◆ fn01

◆ fn1

◆ ialdesi1

◆ icmd1

◆ icoordinate1

◆ idesvar1

◆ ielas1

◆ ielmat1

◆ ielorien1

◆ ielprop1

◆ iinc1

◆ ikin1

◆ iout1

◆ iperturb1

◆ ipkon1

◆ iprestr1

◆ istep1

◆ ithermal1

◆ kon1

◆ lakon1

◆ matname1

◆ mi1

◆ mortar1

◆ mt1

◆ nalcon1

◆ ncmat1_

◆ ne01

◆ ne1

◆ nelcon1

◆ nener1

◆ nk1

◆ nkon1

◆ nmethod1

◆ nodedesi1

◆ norien1

◆ nplicon1

◆ nplkcon1

◆ npmat1_

◆ nrhcon1

◆ nstate1_

◆ ntmat1_

◆ num_cpus

◆ orab1

◆ plicon1

◆ plkcon1

◆ pmastsurf1

◆ prestr1

◆ prop1

◆ pslavsurf1

◆ reltime1

◆ rhcon1

◆ springarea1

◆ sti1

◆ stiini1

◆ stx1

◆ t01

◆ t11

◆ thicke1

◆ time1