Subversion Repositories sifel

Compare Revisions

Ignore whitespace Rev 639 → Rev 640

/trunk/SIFEL/MEFEL/PREP/output.cpp
1279,7 → 1279,7
long i, j, n, ndofn;
 
// total number of prescribed displacements
fprintf(out, "# time dpependent prescribed displacements\n");
fprintf(out, "# time dependent prescribed displacements\n");
fprintf(out, "%ld\n", Numpd);
if (Numpd == 0)
return(0);
/trunk/SIFEL/MEFEL/SRC/Makefile
43,7 → 43,7
SRCS += elastisomat.cpp elastortomat.cpp element.cpp elemparticle.cpp elemswitch.cpp endnodem.cpp epsolver.cpp fdsolver.cpp flsubdom.cpp fixortodam.cpp
SRCS += generalmod.cpp
SRCS += geoelast.cpp glasgmech.cpp glasgowdam.cpp globmat.cpp
SRCS += graphmat.cpp hardsoft.cpp hissplas.cpp homog.cpp homogmech.cpp hvisolver.cpp inicd.cpp intpoints.cpp hypoplunsatexptherm.cpp
SRCS += graphmat.cpp hardsoft.cpp hissplas.cpp homog.cpp homogmech.cpp hvisolver.cpp inicd.cpp intpoints.cpp isoviscous.cpp hypoplunsatexptherm.cpp
 
SRCS += j2flow.cpp layplate.cpp lbsolver.cpp lemaitre.cpp lenjonesmat.cpp lfssolver.cpp lhsrhs.cpp
SRCS += linhex.cpp linhexrot.cpp lintet.cpp lintetrot.cpp linwedge.cpp llssolver.cpp loadcase.cpp
56,7 → 56,7
SRCS += quadtet.cpp quadwedge.cpp relaxeuroc.cpp scaldam.cpp scaldamcc.cpp seismtool.cpp sequent.cpp
SRCS += shefplast.cpp shellq.cpp shelltr.cpp shrinkmat.cpp simviscous.cpp slipsurf.cpp slopesol.cpp slsolver.cpp
SRCS += soilbeam.cpp soilplateq.cpp soilplatetr.cpp solverm.cpp splas1d.cpp springel.cpp stochdriver.cpp strretalg.cpp
SRCS += therisomat.cpp timeswmat.cpp varelastisomat.cpp vecttens.cpp visplast.cpp
SRCS += therisomat.cpp timeswmat.cpp varelastisomat.cpp vecttens.cpp viselast.cpp visplast.cpp
SRCS += winpast.cpp z2_smoothing.cpp umatunsat2.cpp
 
 
/trunk/SIFEL/MEFEL/SRC/alias.h
81,8 → 81,8
 
 
// aliases for damping types
enum damping {nodamp=0,massdamp=1,stiffdamp=2,rayleighdamp=3};
const enumstr dampingstr[] = {{"nodamp",0}, {"massdamp",1}, {"stiffdamp",2}, {"rayleighdamp",3}};
enum damping {nodamp=0,massdamp=1,stiffdamp=2,rayleighdamp=3,elemdamp=11};
const enumstr dampingstr[] = {{"nodamp",0}, {"massdamp",1}, {"stiffdamp",2}, {"rayleighdamp",3}, {"elemdamp",11}};
const kwdset damping_kwdset(sizeof(dampingstr)/sizeof(*dampingstr), dampingstr);
 
 
152,7 → 152,7
boermaterial=25,druckerprager=26,doubledrprager=27,druckerprager2=28,modcamclaymat=30, modcamclaycoupmat=31,
shefpl=40,chenplast=42, hissplasmat=45,
microplaneM4=50,microsimp=51,microfibro=52,
simvisplas=70,simvisc=71,lemaitr=75,
simvisplas=70,simvisc=71,isovisc=72,lemaitr=75,
layerplate=80,
scaldamage=100,scaldamagecc=101,glasgowdamage=102,anisodamage=104, anisodamagerot=105, ortodamage=106, ortodamagerot=107, fixortodamage=108,
contmat=150, cebfipcontmat=160, damplifmat=170,
163,7 → 163,7
glasgowmechmat=700,
rcmatmodnorm=800,
therisodilat=900,relaxationeuro=951,
damage_plasticity=1000, viscoplasticity=1010,
damage_plasticity=1000, viscoplasticity=1010, viscoelasticity=1020,
creep_damage=1030, time_switchmat=1040, effective_stress=1050, shrinkagemat=1060,
lenjonespot=2000};
const enumstr mattypestr[] = {{"elisomat",1}, {"elgmat3d",2}, {"elortomat",3}, {"simplas1d",10},
171,7 → 171,7
{"mohrcoul",24}, {"boermaterial",25}, {"druckerprager",26}, {"doubledrprager",27}, {"druckerprager2",28},
{"modcamclaymat",30}, {"modcamclaycoupmat",31}, {"shefpl",40}, {"chenplast",42}, {"hissplasmat",45},
{"microplaneM4",50}, {"microsimp",51}, {"microfibro",52},
{"simvisc",71}, {"lemaitr",75},
{"simvisc",71}, {"isovisc",72}, {"lemaitr",75},
{"layerplate",80},
{"scaldamage",100}, {"scaldamagecc",101}, {"glasgowdamage",102},
{"anisodamage", 104 }, {"anisodamagerot", 105 }, {"ortodamage", 106 }, { "ortodamagerot", 107 }, {"fixortodamage", 108},
182,7 → 182,7
{"creepb3",502}, {"creepdpl",503}, {"creeprs",504}, {"creepeffym",505},
{"winklerpasternak",550}, {"consolidation",600}, {"glasgowmechmat",700},
{"therisodilat",900},{"relaxationeuro",951},
{"damage_plasticity",1000}, {"viscoplasticity",1010},
{"damage_plasticity",1000}, {"viscoplasticity",1010}, {"viscoelasticity",1020},
{"creep_damage",1030}, {"time_switchmat",1040}, {"effective_stress",1050}, {"shrinkagemat",1060}, {"lenjonespot",2000}};
const kwdset mattype_kwdset(sizeof(mattypestr)/sizeof(*mattypestr), mattypestr);
 
/trunk/SIFEL/MEFEL/SRC/elemswitch.cpp
3733,8 → 3733,136
 
}
 
/**
The function computes damping %matrix of required element.
 
@param lcid - load case id
@param eid - element id
@param dm - damping %matrix of the element (output)
 
@return The function returns assembled %matrix in the parameter mm.
 
Created by JK, 20.11.2017
*/
void dampmat (long lcid,long eid,matrix &dm)
{
elemtype te;
te = Mt->give_elem_type (eid);
switch (te){
/*
case bar2d:{
Bar2d->mass_matrix (eid,mm);
break;
}
case barq2d:{
Barq2d->res_mass_matrix (eid,mm);
break;
}
case beam2d:{
Beam2d->res_mass_matrix (eid,mm);
break;
}
case bar3d:{
Bar3d->res_mass_matrix (eid,mm);
break;
}
case beam3d:{
Beam3d->res_mass_matrix (eid,mm);
break;
}
 
case spring_1:
case spring_2:
case spring_3:
case spring_4:
case spring_5:
case spring_6:
break;
case planeelementlt:{
Pelt->res_mass_matrix (eid,mm);
break;
}
case planeelementqt:{
Peqt->mass_matrix (eid,mm);
break;
}
case planeelementrotlt:{
Perlt->res_mass_matrix (eid,mm);
break;
}
*/
case planeelementlq:{
Pelq->res_damping_matrix (eid,dm);
break;
}
/*
case planeelementqq:{
Peqq->res_mass_matrix (eid,mm);
break;
}
case planeelementrotlq:{
Perlq->res_mass_matrix (eid,mm);
break;
}
 
case planeelementsubqt:{
Pesqt->res_mass_matrix (eid,mm);
break;
}
 
case cctel:{
Cct->res_mass_matrix (eid,mm);
break;
}
 
case axisymmlt:{
Asymlt->mass_matrix (eid,mm);
break;
}
case axisymmlq:{
Asymlq->mass_matrix (eid,mm);
break;
}
case axisymmqq:{
Asymqq->mass_matrix (eid,mm);
break;
}
 
case lineartet:{
Ltet->mass_matrix (eid,mm);
break;
}
case quadrtet:{
Qtet->mass_matrix (eid,mm);
break;
}
case linearhex:{
Lhex->mass_matrix (eid,mm);
break;
}
case quadrhex:{
Qhex->mass_matrix (eid,mm);
break;
}
case lineartetrot:{
Ltetrot->mass_matrix (eid,mm);
break;
}
case linearhexrot:{
Lhexrot->mass_matrix (eid,mm);
break;
}
*/
default:
print_err("unknown element type is required", __FILE__, __LINE__, __func__);
}
}
 
 
/**
The function computes load %matrix of required element.
/trunk/SIFEL/MEFEL/SRC/elemswitch.h
65,6 → 65,8
void massmat (long lcid,long eid,matrix &mm);
/// function computes intial stiffness %matrix of required element
void initstiffmat (long lcid,long eid,matrix &sm);
/// function computes damping %matrix of required element
void dampmat (long lcid,long eid,matrix &dm);
/// function computes load %matrix of required element
void loadmat (long eid,matrix &lm);
/// function assembles transformation matrix of the element according to local coordinate systems defined in element nodes
/trunk/SIFEL/MEFEL/SRC/fdsolver.cpp
117,7 → 117,7
// mass matrix
mass_matrix (lcid);
// damping matrix
damping_matrix ();
damping_matrix (lcid);
if (Mespr==1) fprintf (stdout,"\n time %f",Mp->time);
261,7 → 261,7
// mass matrix
mass_matrix (lcid);
// damping matrix
damping_matrix ();
damping_matrix (lcid);
if (Mespr==1) fprintf (stdout,"\n time %f",Mp->time);
/trunk/SIFEL/MEFEL/SRC/globmat.cpp
252,7 → 252,7
if (ndofe != ndofemn){
// the element contains hanging node
// the stiffness matrix has to be transformed
// the mass matrix has to be transformed
reallocm (ndofe,ndofemn,alm);
mxm (lm,*Mt->elements[i].tmat,alm);
reallocm (ndofemn,ndofemn,lm);
335,7 → 335,7
if (ndofe != ndofemn){
// the element contains hanging node
// the stiffness matrix has to be transformed
// the initial stiffness matrix has to be transformed
reallocm (ndofe,ndofemn,alm);
mxm (lm,*Mt->elements[i].tmat,alm);
reallocm (ndofemn,ndofemn,lm);
359,13 → 359,23
 
Created by JK, 10.8.2005
*/
void damping_matrix ()
void damping_matrix (long lcid)
{
if (Dmat==NULL) Dmat = new gmatrix;
//Dmat->ts=Mp->tstorsm;
long i,ndofe,ndofemn;
ivector cn;
matrix lm,alm;
 
if (Dmat==NULL)
Dmat = new gmatrix;
if (Mp->damp==elemdamp){
// damping is defined by material model
Dmat->initiate (Gtm,Ndofm,Mp->tstordm,Mespr,Out);
}else{
// damping matrix is a multiple of the mass or stiffness matrix
Dmat->initiate (Gtm,Ndofm,Mp->tstorsm,Mespr,Out);
}
Dmat->setval (Mp->ssle);
Dmat->initiate (Gtm,Ndofm,Mp->tstorsm,Mespr,Out);
//Dmat->setval (Mp->ssle.tlinsol,Mp->ssle.prec.pt,Mp->ssle.ni,Mp->ssle.err);
switch (Mp->damp){
case nodamp:{
384,6 → 394,42
Dmat->addgm (Mp->dstiff,*Smat);
break;
}
case elemdamp:{
// damping matrix is assembled element by element
for (i=0;i<Mt->ne;i++){
if (Gtm->leso[i]==1){
// only elements which are switched on are taken into account
// number of DOFs on the i-th element
ndofe = Mt->give_ndofe (i);
// allocation of element mass matrix
reallocm (ndofe,ndofe,lm);
// computation of damping matrix of one element
dampmat (lcid,i,lm);
// the number of DOFs on element
// this number is equal to the number of DOFs with master nodes generated by hanging nodes
ndofemn = Gtm->give_ndofe (i);
reallocv (ndofemn,cn);
Mt->give_code_numbers (i,cn.a);
if (ndofe != ndofemn){
// the element contains hanging node
// the damping matrix has to be transformed
reallocm (ndofe,ndofemn,alm);
mxm (lm,*Mt->elements[i].tmat,alm);
reallocm (ndofemn,ndofemn,lm);
mtxm (*Mt->elements[i].tmat,alm,lm);
}
// localization of matrix of element to matrix of problem
Dmat->localize (lm,cn,i);
}
}
break;
}
default:{
print_err("unknown type of damping is required",__FILE__,__LINE__,__func__);
}
/trunk/SIFEL/MEFEL/SRC/globmat.h
12,7 → 12,7
void stiffness_matrix (long lcid);
void mass_matrix (long lcid);
void initial_stiffness_matrix (long lcid);
void damping_matrix ();
void damping_matrix (long lcid);
void layered_stiffness_matrix ();
 
void internal_forces (long lcid,double *intfor);
/trunk/SIFEL/MEFEL/SRC/isoviscous.cpp
0,0 → 1,164
#include <math.h>
#include "isoviscous.h"
#include "global.h"
#include "matrix.h"
#include "vector.h"
#include "intpoints.h"
 
 
 
/**
Constructor initializes data members to zero or default values.
 
Created by JK,
*/
isoviscous::isoviscous (void)
{
// coefficient of volumetric viscosity
xi=0.0;
// coefficient of dynamic viscosity
eta=0.0;
}
 
 
 
/**
Destructor is defined only for the formal purposes.
 
Created by JK,
*/
isoviscous::~isoviscous (void)
{
 
}
 
 
 
/**
Function reads material parameters from the opened text file.
@param in - pointer to the opened XFILE
 
@return The function does not return anything.
 
Created by JK, 20.11.2017
*/
void isoviscous::read (XFILE *in)
{
// coefficient of volumetric viscosity, coefficient of dynamic viscosity
xfscanf (in,"%k %lf %k %lf", "xi", &xi, "eta", &eta);
}
 
 
 
/**
The function prints model parameters in to the opened text file.
 
@param out - pointer to the opened text file for output
 
@return The function does not return anything.
 
Created by JK, 20.11.2017
*/
void isoviscous::print (FILE *out)
{
fprintf (out, "%le %le", xi,eta);
}
 
 
/**
Function assembles damping %matrix of material.
@param d - damping %matrix of material (output)
@param ssst - strain/stress state
 
@return The function returns material damping %matrix in the parameter d.
 
Created by JK, 20.11.2017
*/
void isoviscous::matdamp (matrix &d,strastrestate ssst)
{
switch (ssst){
/*
case bar:{
matstiff_bar (d);
break;
}
case plbeam:{
matstiff_plbeam (d);
break;
}
case spacebeam:{
matstiff_spacebeam (d);
break;
}
*/
case planestress:{
matdamp_plstress (d);
break;
}
/*
case planestrain:{
matstiff_plstrain (d);
break;
}
case platek:{
matstiff_platek (d);
break;
}
case plates:{
matstiff_plates (d);
break;
}
case axisymm:{
matstiff_axi (d);
break;
}
*/
case spacestress:{
matdamp_spacestr (d);
break;
}
default:{
print_err("unknown number of components of stress tensor is required", __FILE__, __LINE__, __func__);
}
}
}
 
/**
Function creates damping matrix of the viscous
isotropic material for 2D problems (plane stress).
 
@param d - damping matrix of the material
 
@return The function returns material damping %matrix in the parameter d.
 
Created by JK, 20.11.2017
*/
void isoviscous::matdamp_plstress (matrix &d)
{
fillm(0.0,d);
d[0][0] = xi+eta/3.0; d[0][1] = xi-2.0/3.0*eta; d[0][2] = 0.0;
d[1][0] = xi-2.0/3.0*eta; d[1][1] = xi+eta/3.0; d[1][2] = 0.0;
d[2][0] = 0.0; d[2][1] = 0.0; d[2][2] = eta;
}
 
/**
Function creates damping %matrix of the viscous
isotropic material for 3D problems.
@param d - damping %matrix of the material
 
Created by JK, 20.11.2017
*/
void isoviscous::matdamp_spacestr (matrix &d)
{
fillm(0.0,d);
d[0][0] = xi+eta/3.0; d[0][1] = xi-2.0/3.0*eta; d[0][2] = xi-2.0/3.0*eta;
d[1][0] = xi-2.0/3.0*eta; d[1][1] = xi+eta/3.0; d[1][2] = xi-2.0/3.0*eta;
d[2][0] = xi-2.0/3.0*eta; d[2][1] = xi-2.0/3.0*eta; d[2][2] = xi+eta/3.0;
 
d[3][3] = eta; d[4][4]=eta; d[5][5]=eta;
}
/trunk/SIFEL/MEFEL/SRC/isoviscous.h
0,0 → 1,35
#ifndef ISOVISCOUS_H
#define ISOVISCOUS_H
 
#include "alias.h"
#include "iotools.h"
struct matrix;
struct vector;
 
 
/**
material model for isotropic viscous material
 
*/
class isoviscous
{
public:
isoviscous (void);
~isoviscous (void);
void read(XFILE *in);
void print(FILE *out);
void matdamp (matrix &d,strastrestate ssst);
void matdamp_plstress (matrix &d);
void matdamp_spacestr (matrix &d);
 
/// coefficient of volumetric viscosity
double xi;
/// coefficient of dynamic viscosity
double eta;
};
 
#endif
/trunk/SIFEL/MEFEL/SRC/mechmat.cpp
76,9 → 76,10
#include "hypoplunsatexptherm.h"
#include "umatunsat2.h"
#include "layplate.h"
#include "viselast.h"
#include "isoviscous.h"
#include "inicd.h"
 
 
/**
Constructor initializes data members to zero or default values.
 
125,7 → 126,7
boerm=NULL; drprm=NULL; ddpm=NULL; drprm2=NULL; cclay=NULL; cclayc=NULL; shpl=NULL; hisspl=NULL;
glasgmat=NULL; glasgdam=NULL; crdam=NULL; tswmat=NULL; ntswmat=0L; effstr=NULL;
mpM4=NULL; mpSIM=NULL; mpfib=NULL; nmpM4=NULL;
svis=NULL; svipl=NULL; lmtr=NULL;
svis=NULL; isovis=NULL; svipl=NULL; lmtr=NULL;
scdam=NULL; anidam=NULL; anidamrot=NULL; ortdam=NULL;
ortdam=NULL; ortdamrot=NULL;
aci78mod=NULL; cebfip78mod=NULL;
138,7 → 139,7
nlplast=NULL; nldamg=NULL;
hypopl=NULL; hypoplustherm=NULL;
 
dampl = NULL; visplas = NULL;
dampl = NULL; visplas = NULL; viselas=NULL;
chplast = NULL;
lenjon = NULL;
conmat=NULL;
204,7 → 205,7
 
delete [] mpM4; delete [] mpSIM; delete [] mpfib; delete [] nmpM4;
 
delete [] svis;
delete [] svis; delete [] isovis;
delete [] lmtr;
 
delete [] scdam; delete [] anidam; delete [] anidamrot;
216,7 → 217,7
delete [] crbaz; delete [] csol; delete [] wpast;
delete [] tidilat; delete [] relaxec;
delete [] nlplast; delete [] nldamg;
delete [] dampl; delete [] visplas;
delete [] dampl; delete [] visplas; delete [] viselas;
delete [] chplast;
delete [] lenjon; delete [] conmat; delete [] cebfipconmat;
delete [] lplate;
1319,6 → 1320,18
}
break;
}
case isovisc:{
if (Mespr==1) fprintf (stdout,"\n number of viscous materials for isotropic material %ld",numt);
isovis = new isoviscous [numt];
for (j=0;j<numt;j++){
k=numt+1;
xfscanf (in,"%ld",&k);
if (k>numt || k<1)
print_err("wrong number of viscous material for isotropic material in function",__FILE__,__LINE__,__func__);
isovis[k-1].read (in);
}
break;
}
case lemaitr:{
if (Mespr==1) fprintf (stdout,"\n number of Lemaitre visco materials %ld",numt);
lmtr = new lemaitre [numt];
1637,6 → 1650,18
}
break;
}
case viscoelasticity:{
if (Mespr==1) fprintf (stdout,"\n number of artificial material of viscoelasticity %ld",numt);
viselas = new viselast [numt];
for (j=0;j<numt;j++){
k=numt+1;
xfscanf (in,"%ld",&k);
if (k>numt || k<1)
print_err("wrong number of artificial material of viscoelasticity",__FILE__,__LINE__,__func__);
}
break;
}
 
case lenjonespot:{
if (Mespr==1) fprintf (stdout,"\n number of Lennard-Jones interatomic potentials %ld",numt);
1806,6 → 1831,10
svis[numinst].print(out);
break;
}
case isovisc:{
isovis[numinst].print(out);
break;
}
case hypoplastusatthermat:{
hypoplustherm[numinst].print (out);
break;
1847,6 → 1876,9
case viscoplasticity:{
break;
}
case viscoelasticity:{
break;
}
case time_switchmat:{
tswmat[numinst].print(out);
break;
2202,6 → 2234,7
initvalues(lcid,ipp, im+1, ido);
break;
case simvisc:
case isovisc:
case lemaitr:
case scaldamage:
case scaldamagecc:
2244,6 → 2277,7
case nonlocdamgmat:
case damage_plasticity:
case viscoplasticity:
case viscoelasticity:
case creepeffym:
case rcmatmodnorm:
break;
3038,6 → 3072,7
case therisodilat:
case relaxationeuro:
case simvisc:
case isovisc:
case lenjonespot:{
ncompo = givencompeqother (ipp,im);
break;
3065,6 → 3100,7
case lemaitr:
case glasgowmechmat:
case viscoplasticity:
case viscoelasticity:
ncompo=0;
break;
case time_switchmat:
3199,6 → 3235,9
case simvisc:
ncompo=3*ncompstr;
break;
case isovisc:
ncompo=0;
break;
case lemaitr:
ncompo=3*ncompstr+2;
break;
3273,6 → 3312,9
ncompo = givencompeqother (ipp, im+1); // viscous material model
ncompo += givencompeqother (ipp, im+2); // plasticity material model
break;
case viscoelasticity:
ncompo = givencompeqother (ipp, im+1); // viscous material model
break;
case therisodilat:{
break;
}
4837,6 → 4879,7
case lemaitr:
case glasgowmechmat:
case viscoplasticity:
case viscoelasticity:
case lenjonespot:
case creep_damage:
case creepdpl:
5243,6 → 5286,12
break;
}
 
case viscoelasticity:{
i=ip[ipp].idm[im];
viselas[i].matstiff (d,ipp,im,ido);
break;
}
 
case contmat:{
i=ip[ipp].idm[im];
conmat[i].matstiff (d,ipp);
5420,7 → 5469,42
}
 
 
/**
Function computes stiffness %matrix of the material
in the required integration point.
 
@param d - stiffness %matrix (output)
@param ipp - number of integration point
@param im - index of the material in the ipp tm and idm arrays. The standard value is zero.
@param ido - index of internal variables in the ip's ipp other array
@return The function returns stiffness %matrix in the parametr d.
 
Created by JK, 17.7.2001
*/
void mechmat::matdamp (matrix &d,long ipp,long im,long ido)
{
long i;
 
switch (ip[ipp].tm[im]){
case viscoelasticity:{
i=ip[ipp].idm[im];
viselas[i].matdamp (d,ipp,im,ido);
break;
}
case isovisc:{
i=ip[ipp].idm[im];
isovis[i].matdamp (d,ip[ipp].ssst);
break;
}
default:
print_err("unknown material type is required",__FILE__,__LINE__,__func__);
 
}
}
 
 
 
/**
Function computes eigenstresses in required integration point.
5670,6 → 5754,10
visplas[ip[ipp].idm[im]].nlstresses (ipp,ido);
break;
}
case viscoelasticity:{
viselas[ip[ipp].idm[im]].nlstresses (ipp);
break;
}
 
case contmat:{
/trunk/SIFEL/MEFEL/SRC/mechmat.h
34,6 → 34,7
class effstress;
class svisplas;
class simviscous;
class isoviscous;
class lemaitre;
class scaldam;
class fixortodam;
60,6 → 61,7
class damplast;
class geoelastmat;
class visplast;
class viselast;
class chen;
class lenjonesmat;
class contactmat;
395,6 → 397,9
 
/// computes elastic complience matrix
void elmatcompl (matrix &c, long ipp);
/// computes damping matrix of material
void matdamp (matrix &d,long ipp,long im=0,long ido=0);
 
/// computes eigenstress and corresponding eigenstrains defined by relaxation material models
void eigenstresses (vector &sig, long ipp, long id);
767,6 → 772,8
/// simple model of viscosity
simviscous *svis;
/// viscous model for isotropic material
isoviscous *isovis;
/// simple visco-plastic material
svisplas *svipl;
/// Lemaitre visco-plastic model
836,6 → 843,9
damplast *dampl;
///
visplast *visplas;
/** artificial model for elastic and viscous material model
the model is intended for definition of damping */
viselast *viselas;
/// Chen model of plasticity of concrete
chen *chplast;
/trunk/SIFEL/MEFEL/SRC/ndsolver.cpp
114,7 → 114,7
// mass matrix
mass_matrix (lcid);
// damping matrix
damping_matrix ();
damping_matrix (lcid);
if (Mespr==1) fprintf (stdout,"\n time %f",Mp->time);
/trunk/SIFEL/MEFEL/SRC/plelemlq.cpp
622,7 → 622,7
// matrix of stiffness of the material
Mm->matstiff (d,ipp);
 
// block os the stiffness matrix of the material
// block of the stiffness matrix of the material
dmatblock (ii,jj,d,dd);
 
// thickness in integration point
842,11 → 842,112
}
 
 
/**
function computes damping %matrix of plane rectangular
finite element with bilinear approximation functions
function computes stiffness %matrix for geometrically linear problems
@param eid - number of element
@param ri,ci - row and column indices
@param sm - stiffness %matrix
@param x,y - vectors of nodal coordinates
JK, 20.11.2017
*/
void planeelemlq::damping_matrix (long eid,long ri,long ci,matrix &sm,vector &x,vector &y)
{
long i,j,ii,jj,ipp;
double xi,eta,jac,thick;
ivector nodes(nne);
vector w,gp,t(nne);
matrix gmr,gmc,dd,d(tncomp,tncomp);
 
Mt->give_elemnodes (eid,nodes);
Mc->give_thickness (eid,nodes,t);
 
fillm (0.0,sm);
 
for (ii=0;ii<nb;ii++){
reallocm (ncomp[ii],ndofe,gmr);
for (jj=0;jj<nb;jj++){
if (intordsm[ii][jj]==0) continue;
 
reallocv (intordsm[ii][jj],w);
reallocv (intordsm[ii][jj],gp);
 
reallocm (ncomp[jj],ndofe,gmc);
reallocm (ncomp[ii],ncomp[jj],dd);
 
gauss_points (gp.a,w.a,intordsm[ii][jj]);
 
ipp=Mt->elements[eid].ipp[ri+ii][ci+jj];
 
for (i=0;i<intordsm[ii][jj];i++){
xi=gp[i];
for (j=0;j<intordsm[ii][jj];j++){
eta=gp[j];
 
// blocks of geometric matrices
geom_matrix_block (gmr,ii,x,y,xi,eta,jac);
geom_matrix_block (gmc,jj,x,y,xi,eta,jac);
 
// matrix of damping of the material
Mm->matdamp (d,ipp);
 
// block of the damping matrix of the material
dmatblock (ii,jj,d,dd);
 
// thickness in integration point
thick = approx (xi,eta,t);
 
jac*=thick*w[i]*w[j];
jac=fabs(jac);
 
// contribution to the damping matrix of the element
bdbjac (sm,gmr,dd,gmc,jac);
ipp++;
}
}
}
}
}
 
/**
function assembles damping %matrix of plane stress rectangular
finite element with bilinear approximation functions
@param eid - element id
@param mm - damping %matrix
JK, 20.11.2017
*/
void planeelemlq::res_damping_matrix (long eid,matrix &dm)
{
long transf;
ivector nodes(nne);
vector x(nne),y(nne);
Mt->give_node_coord2d (x,y,eid);
 
damping_matrix (eid,0,0,dm,x,y);
// transformation of damping matrix
// (in the case of nodal coordinate systems)
Mt->give_elemnodes (eid,nodes);
transf = Mt->locsystems (nodes);
if (transf>0){
matrix tmat (ndofe,ndofe);
transf_matrix (nodes,tmat);
glmatrixtransf (dm,tmat);
}
}
 
 
 
/**
function computes strains at integration points
@param lcid - load case id
/trunk/SIFEL/MEFEL/SRC/plelemlq.h
56,6 → 56,8
void mass_matrix (long eid,matrix &mm,vector &x,vector &y);
void res_mass_matrix (long eid,matrix &mm);
void damping_matrix (long eid,long ri,long ci,matrix &sm,vector &x,vector &y);
void res_damping_matrix (long eid,matrix &dm);
 
void res_ip_strains (long lcid,long eid);
void gl_ip_strains (long lcid,long eid,long ri,long ci,vector &x,vector &y,vector &r);
/trunk/SIFEL/MEFEL/SRC/probdesc.cpp
484,6 → 484,10
if (Mespr==1) fprintf (stdout,"\n Rayleigh damping (proportional to the mass and stiffness matrices) is prescribed");
break;
}
case elemdamp:{
if (Mespr==1) fprintf (stdout,"\n damping is defined on finite elements");
break;
}
default:{
print_err("unknown type of damping is required",__FILE__,__LINE__,__func__);
}
491,9 → 495,12
 
// type of storage of stiffness matrix
// type of storage of mass matrix
xfscanf (in,"%k%m%k%m","stiffmatstor",&storagetype_kwdset,(int*)&tstorsm,"massmatstor",&storagetype_kwdset,(int*)&tstormm);
// type of storage of damping matrix is defined by type of damping
xfscanf (in,"%k%m%k%m","stiffmatstor",&storagetype_kwdset,(int*)&tstorsm,"massmatstor",&storagetype_kwdset,(int*)&tstormm);
 
if (damp==elemdamp){
xfscanf (in,"%k%m","dampmatstor",&storagetype_kwdset,(int*)&tstordm);
}
// time controller
timecon.read (in);
 
1039,6 → 1046,9
fprintf (out,"%e %e\n",dstiff,dmass);
break;
}
case elemdamp:{
break;
}
default:{
print_err("unknown type of damping is required",__FILE__,__LINE__,__func__);
}
1045,7 → 1055,10
}
fprintf (out,"%d %d\n",(int)tstorsm,(int)tstormm);
 
if (damp==elemdamp){
fprintf (out,"%d\n",(int)tstordm);
}
timecon.print (out);
 
ssle->print (out);
/trunk/SIFEL/MEFEL/SRC/probdesc.h
51,6 → 51,8
storagetype tstorsm;
/// type of storage of mass matrix
storagetype tstormm;
/// type of storage of damping matrix
storagetype tstordm;
 
/// DAMPING
/trunk/SIFEL/MEFEL/SRC/viselast.cpp
0,0 → 1,88
#include "viselast.h"
#include "global.h"
#include "intpoints.h"
 
viselast::viselast (void)
{
 
}
 
 
viselast::~viselast (void)
{
 
}
 
/**
This function computes material stiffnes %matrix.
 
@param d - allocated matrix structure for material stiffness %matrix
@param ipp - integration point number
 
*/
void viselast::matstiff (matrix &d,long ipp,long im,long ido)
{
//switch (Mp->nlman->stmat){
//case initial_stiff:{
Mm->elmatstiff (d,ipp);
//break;
//}
//case tangent_stiff:{
//Mm->elmatstiff (d,ipp);
//break;
//}
//default:{
//print_err("unknown type of stifness matrix is required",__FILE__,__LINE__,__func__);
//}}
}
 
/**
This function computes material damping %matrix.
 
@param d - allocated matrix structure for material damping %matrix
@param ipp - integration point number
 
*/
void viselast::matdamp (matrix &d,long ipp,long im,long ido)
{
Mm->matdamp (d,ipp,im+1,ido);
}
 
 
/**
Function computes true stresses.
@param ipp - number of integration point
@return The function does not return anything.
 
Created by JK,
*/
void viselast::nlstresses (long ipp)
{
long i, n = Mm->ip[ipp].ncompstr;
vector eps(n),sig(n);
strastrestate ssst = Mm->ip[ipp].ssst;
matrix d(n,n);
// initial values
for (i=0;i<n;i++){
eps[i]=Mm->ip[ipp].strain[i];
}
Mm->elmatstiff (d,ipp);
mxv (d,eps,sig);
/*
if (Mm->ip[ipp].ssst == planestress)
Mm->ip[ipp].strain[3] = -nu / (1.0 - nu) * (eps[0]+eps[1]);
*/
if ((Mp->eigstrains == 4) || (Mp->eigstrains == 5))
{
for (i=0;i<n;i++)
sig(i) += Mm->eigstresses[ipp][i];
}
for (i=0;i<n;i++){
Mm->ip[ipp].stress[i]=sig[i];
}
}
/trunk/SIFEL/MEFEL/SRC/viselast.h
0,0 → 1,36
#ifndef VISELAST_H
#define VISELAST_H
 
#include <stdio.h>
#include "alias.h"
struct matrix;
struct vector;
 
/**
artificial material model for combination of viscous and plastic material models
viscous material is the first one while plastic material is the second one
structure of eqother array of a visco-plastic material:
increments of stress components, previous total strains, increments of irreversible strains,
consistency parameter, hardening parameters
direct access from viscous material: increments of stress components, previous total strains, previous total stress
direct access from plastic material: total irreversible strains, consistency parameter,
hardening parameters
25.6.2004,
*/
class viselast
{
public:
viselast (void);
~viselast (void);
 
void matstiff (matrix &d,long ipp,long im,long ido);
void matdamp (matrix &d,long ipp,long im,long ido);
void nlstresses (long ipp);
 
};
 
#endif
/trunk/SIFEL/TRFEL/SRC/Makefile
44,7 → 44,7
SRCS += npsolvert.cpp nspsolvert.cpp onemedium.cpp outdiagt.cpp outdrivert.cpp o30bazant.cpp pedersen.cpp
SRCS += probdesct.cpp pvalt.cpp quadbart.cpp quadbartax.cpp quadhext.cpp quadlinaxisym.cpp quadlineart.cpp
SRCS += quadquadrilatt.cpp quadquadrilattax.cpp radiationmat.cpp richards.cpp richardscontam.cpp saltmat1.cpp saltmat2.cpp saltmat3.cpp saltmat4.cpp seebeckheat.cpp
SRCS += sejtkrmat.cpp soil1mat.cpp solvert.cpp sorpisohansen.cpp sorpisorootgrun.cpp sourcet.cpp spsolvert.cpp stochdrivert.cpp
SRCS += sejtkrmat.cpp soil1mat.cpp solvert.cpp sorpisohansen.cpp sorpisorootgrun.cpp sourcet.cpp spsolvert.cpp stochdrivert.cpp tdisotrmat.cpp
SRCS += threemedia.cpp transbclc.cpp transcrsec.cpp transmat.cpp transprint.cpp transtop.cpp trfelinit.cpp
SRCS += trlinaxisym.cpp trlineart.cpp twomedia.cpp adaptivityt.cpp
 
/trunk/SIFEL/TRFEL/SRC/aliast.h
89,7 → 89,7
o30bazantB=167, C60bazantB=168, C30bazantB=169, glasgow=170, carb1mat=171, moistheat=180,
richardsmat=181,
salt1mat=200, salt2mat=201, salt3mat=202, salt4mat=203, radiationmater=251,
soilmat1=300, discontisotrmat=401,
soilmat1=300, discontisotrmat=401, tdisotransmat=421,
cementhydrmat=500, sejtkr=650, consolawf1=600, consolawf2=700, consolhawf3=800};
const enumstr mattypetstr[] = {{"isotransmat",100},{"cernyconcrete",101},{"nlisotransmat",102},
{"damisotransmat",103}, {"homomat",110},{"lincoupledmat",120},{"interfacem",131},
100,7 → 100,7
{"richardsmat",181},
{"salt1mat",200},{"salt2mat",201},{"salt3mat",202},{"salt4mat",203},
{"radiationmater",251},
{"soilmat1",300},{"discontisotrmat",401},
{"soilmat1",300},{"discontisotrmat",401},{"tdisotransmat",421},
{"cementhydrmat",500},{"sejtkr",650},{"consolawf1",600},{"consolawf2",700},{"consolhawf3",800}};
const kwdset mattypet_kwdset(sizeof(mattypetstr)/sizeof(*mattypetstr), mattypetstr);
 
/trunk/SIFEL/TRFEL/SRC/isotrmat.cpp
174,7 → 174,7
*/
void isotrmat::print (FILE *out)
{
fprintf (out," %e %e",c,k);
fprintf (out," %e %e\n",c,k);
}
 
/**
/trunk/SIFEL/TRFEL/SRC/linbart.cpp
517,6 → 517,12
fillm (0.0,n);
bf_lin_1d (n.a,xi);
 
double h=1.2500000000e-03;
double nor=1.507500e-07;
double pe=nor*h/2.0/9.52e-12;
alpha=(exp(pe)+exp(0.0-pe))/(exp(pe)-exp(0.0-pe))-1.0/pe;
//alpha=1.0;
 
if (v<0.0){
w[0][0]=n[0][0]+alpha/2.0;
w[0][1]=n[0][1]-alpha/2.0;
/trunk/SIFEL/TRFEL/SRC/onemedium.cpp
72,6 → 72,10
Tm->ditrm[i].matcond(d,ri,ci,ipp);
break;
}
case tdisotransmat:{
Tm->tditrm[i].matcond(d,ri,ci,ipp);
break;
}
case interfacem:{
Tm->ifacemat[i].matcond(d,ri,ci,ipp);
break;
137,7 → 141,12
case damisotransmat:{
break;
}
case sejtkr:
case tdisotransmat:{
break;
}
case sejtkr:{
break;
}
case consolawf1:{
break;
}
244,6 → 253,10
Tm->damitrm[i].matcap(c,ri,ci,ipp);
break;
}
case tdisotransmat:{
Tm->tditrm[i].matcap(c,ri,ci,ipp);
break;
}
case discontisotrmat:{
Tm->ditrm[i].matcap(c,ri,ci,ipp);
break;
299,6 → 312,7
Tm->consol_awf1[i].rhs_volume(d,ri,ci,ipp);
break;
case isotransmat:
case tdisotransmat:
case nlisotransmat:
case discontisotrmat:
case cernyconcrete:
/trunk/SIFEL/TRFEL/SRC/quadlineart.cpp
664,7 → 664,7
void quadlineart::tf_matrix (matrix &w,double xi,double eta,matrix &d,long eid)
{
long i;
double alpha=1.0,jac,h,nor;
double alpha,jac,h,nor,pe;
vector dx(nne),dy(nne),x(nne),y(nne),v(2);
matrix n(1,dofe[0][0]);
fillm (0.0,n);
694,9 → 694,14
// characteristic size of the element
h = Gtt->give_characteristic_size (eid);
//h=1.2500000000e-03;
 
pe=nor*h/2.0/9.52e-12;
alpha=(exp(pe)+exp(0.0-pe))/(exp(pe)-exp(0.0-pe))-1.0/pe;
alpha =1.0;
 
for (i=0;i<nne;i++){
w[0][i]=n[0][i]+(dx[i]*v[0]+dy[i]*v[1])*alpha*h/nor;
w[0][i]=n[0][i]+(dx[i]*v[0]+dy[i]*v[1])*alpha*h/nor/2.0;
}
}
 
858,7 → 863,7
// matrix of gradients of approximation functions
grad_matrix (gm,x,y,xi,eta,jac);
// matrix of gradients of test functions
grad_btf_matrix (gmt,x,y,xi,eta,jac,eid,ii,ri,ci);
//grad_btf_matrix (gmt,x,y,xi,eta,jac,eid,ii,ri,ci);
// matrix of conductivity of the material
reallocm(ncomp,ncomp,d);
876,7 → 881,8
jac*=thick*ww1*ww2;
// contribution to the conductivity matrix of the element
bdbjac(km, gmt, d, gm, jac);
//bdbjac(km, gmt, d, gm, jac);
bdbjac(km, gm, d, gm, jac);
// convective terms
reallocm(1,ncomp,d);
/trunk/SIFEL/TRFEL/SRC/tdisotrmat.cpp
0,0 → 1,286
/*
File: tdisotrmat.cpp
Author: Jaroslav Kruis, 7.12.2017
Purpose: Calculates properties of general time dependent isotropic material for onemedium transfer
*/
#include "tdisotrmat.h"
#include "stochdrivert.h"
#include "globalt.h"
 
tdisotrmat::tdisotrmat (void)
{
// capacity
c=0.0;
}
 
 
 
tdisotrmat::~tdisotrmat (void)
{
}
 
 
 
/**
function computes conductivity %matrix of the material
in the required integration point
@param d - conductivity %matrix of material
@param ri - row index
@param ci - column index
@param ipp - number of integration point
 
*/
void tdisotrmat::matcond (matrix &d,long ri,long ci,long ipp)
{
long n;
n = d.n;
 
switch (n){
case 1:{
matcond1d (d,ri,ci,ipp);//1D
break;
}
case 2:{
matcond2d (d,ri,ci,ipp);//2D
break;
}
case 3:{
matcond3d (d,ri,ci,ipp);//3D
break;
}
default:{
print_err("unknown number of components of conductivity tensor is required",__FILE__,__LINE__,__func__);
}
}
}
 
 
/**
function creates conductivity %matrix of the material for 1D problems
 
@param d - conductivity %matrix of the material
@param ri - row index
@param ci - column index
@param ipp - number of integration point
*/
void tdisotrmat::matcond1d (matrix &d,long ri,long ci,long ipp)
{
double kk;
 
kk = get_k();
//double cf = Tm->ip[ipp].av[0];
//kk=kk/(1.0+4.9/(1.0+3335.0*cf)/(1.0+3335.0*cf));
//if (cf<1.0e-9)
//cf=1.0e-9;
//kk=kk/(1.0+0.013096544*0.36*pow(cf,-0.64));
d[0][0] = kk;
}
 
/**
function creates conductivity %matrix of the material for 2D problems
 
@param d - conductivity %matrix of the material
@param ri - row index
@param ci - column index
@param ipp - number of integration point
*/
void tdisotrmat::matcond2d (matrix &d,long ri,long ci,long ipp)
{
double kk;
 
kk = get_k();
//double cf = Tm->ip[ipp].av[0];
//kk=kk/(1.0+4.9/(1.0+3335.0*cf)/(1.0+3335.0*cf));
//double cf = Tm->ip[ipp].av[0];
//if (cf<1.0e-9)
//cf=1.0e-9;
//kk=kk/(1.0+1.03*0.36/0.08*pow(cf,-0.64));
//kk=kk/(1.0+0.013096544*0.36*pow(cf,-0.64));
 
 
fillm(0.0,d);
d[0][0] = kk; d[0][1] = 0.0;
d[1][0] = 0.0; d[1][1] = kk;
}
 
/**
function creates conductivity %matrix of the material for 3D problems
 
@param d - conductivity %matrix of the material
@param ri - row index
@param ci - column index
@param ipp - number of integration point
*/
 
void tdisotrmat::matcond3d (matrix &d,long ri,long ci,long ipp)
{
double kk;
 
kk = get_k();
fillm(0.0,d);
d[0][0]=kk; d[0][1]=0.0; d[0][2]=0.0;
d[1][0]=0.0; d[1][1]=kk; d[1][2]=0.0;
d[2][0]=0.0; d[2][1]=0.0; d[2][2]=kk;
}
 
 
/**
function creates capacity %matrix of the material
 
@param c - capacity %matrix of the material
@param ri - row index
@param ci - column index
@param ipp - number of integration point
*/
void tdisotrmat::matcap (double &cc,long ri,long ci,long ipp)
{
cc = 0.0;
cc = get_c();
 
//double cf = Tm->ip[ipp].av[0];
//cc = 1.0 + 9.8/(1.0+7250.0*cf)/(1.0+7250.0*cf);
//cc = 1.0 + 4.9/(1.0+3335.0*cf)/(1.0+3335.0*cf);
//cc=1.0;
}
 
 
/**
function reads parameters
@param in - input file
*/
void tdisotrmat::read (XFILE *in)
{
// c - capacity
xfscanf (in,"%lf",&c);
// k - conductivity
k.read (in);
}
 
 
/**
function prints parameters
@param out - outut file
*/
void tdisotrmat::print (FILE *out)
{
fprintf (out," %e\n",c);
k.print (out);
}
 
/**
function creates conductivity coefficient of the isotropic material
 
@retval k - heat conductivity %matrix of the isotropic material
*/
 
double tdisotrmat::get_k()
{
return k.getval(Tp->time);
}
 
/**
function creates specific heat of the isotropic material
@retval c - specific heat of the isotropic material
*/
double tdisotrmat::get_c()
{
return(c);
}
 
 
 
/**
Function returns volumetric moisture content in the given integration point.
@param ipp - integration point id
 
@return Funtion returns value of volumetric moisture content stored in the integartion point.
 
Created by Tomas Koudelka, 13.1.2016
*/
double tdisotrmat::give_vol_moist(long ipp)
{
if (Tp->mednam == moisture)
return Tm->ip[ipp].av[0];
else
print_err("invalid moisture quantity is required in tdisotrmat", __FILE__, __LINE__, __func__);
 
return 0.0;
}
 
 
 
/**
The function returns ordered dof names of primary unknowns
required by the model.
 
@param dofname - array of uknown name for particular nodal dofs (output)
dofname[i] = name of i-th nodal unknown (for names see aliast.h - enum namevart)
@param ntm - number of transported media = number of nodal dof = length of array dofname
 
Created by Tomas Koudelka, 6.12.2013
*/
void tdisotrmat::give_dof_names (namevart *dofname, long ntm)
{
if (ntm < 1)
{
print_err("the model defines %ld unknowns but number of transported media is %ld",
__FILE__, __LINE__, __func__, 1, ntm);
abort();
}
if (Tp->mednam == moisture)
dofname[0] = trf_moisture;
else
dofname[0] = trf_temperature;
}
 
 
 
/**
function changes parameters of conductivity and capacity from a table
@ param
*/
void tdisotrmat::changeparam (atsel &atm,vector &val)
{
long i;
for (i=0;i<atm.num;i++){
switch (atm.atrib[i]){
case 0:{
c=val[0];
break;
}
default:{
print_err("wrong number of atribute is required",__FILE__,__LINE__,__func__);
}
}
}
}
 
 
 
/**
The funtion marks required non-transport quantities in the array antq.
@param antq - array with flags for used material types
antq[i] = 1 => quantity type nontransquant(i+1) is required
antq[i] = 0 => quantity type nontransquant(i+1) is not required
 
@return The function does not return anything, but it may change content of antq array.
25. 4. 2014, by TKo
*/
void tdisotrmat::give_reqntq(long *antq)
{
}
/trunk/SIFEL/TRFEL/SRC/tdisotrmat.h
0,0 → 1,55
#ifndef TDISOTRMAT_H
#define TDISOTRMAT_H
 
#include <stdio.h>
#include "aliast.h"
#include "genfile.h"
#include "aliast.h"
#include "gfunct.h"
//#include "dampermeability.h"
 
struct vector;
struct atsel;
 
class tdisotrmat
{
public:
tdisotrmat (void);
~tdisotrmat (void);
/// computes conductivity %matrix
void matcond (matrix &d,long ri,long ci,long ipp);
/// computes capacity %matrix
void matcap (double &cc,long ri,long ci,long ipp);
/// computes conductivity %matrix for the 1D problems
void matcond1d (matrix &d,long ri,long ci,long ipp);
/// computes conductivity %matrix for the 2D problems
void matcond2d (matrix &d,long ri,long ci,long ipp);
/// computes conductivity %matrix for the 3D problems
void matcond3d (matrix &d,long ri,long ci,long ipp);
 
/// reads material parameters from the file
void read (XFILE *in);
/// prints material parameters to the file
void print (FILE *out);
 
/// returns the conductivity coefficient
double get_k();
/// returns the capacity coefficient
double get_c();
/// fills dofnames used in the material model
void give_dof_names(namevart *dofname, long ntm);
void changeparam (atsel &atm,vector &val);
/// returns volumetric moisture content in the material point
double give_vol_moist(long ipp);
/// fills array with non-transport quantities required by the model
void give_reqntq(long *antq);
 
// coefficient of conductivity
gfunct k;
// coefficient of capacity
double c;
};
 
#endif
/trunk/SIFEL/TRFEL/SRC/transmat.cpp
38,7 → 38,11
nlitrm=NULL;
// artificial material obtained from homogenization
hommat=NULL;
 
// isotropic material with optional influence of damage
damitrm=NULL;
// time dependent isotropic diffusion
tditrm=NULL;
// material for contact elements
ifacemat=NULL;
108,6 → 112,8
delete [] itrm;
delete [] nlitrm;
delete [] hommat;
delete [] damitrm;
delete [] tditrm;
delete [] ifacemat;
 
delete [] cernym;
615,6 → 621,9
case nlisotransmat:
nlitrm[i].give_dof_names(dofname, ntm);
break;
case tdisotransmat:
tditrm[i].give_dof_names(dofname, ntm);
break;
/*
case nlisotransmat:
1376,7 → 1385,20
}
break;
}
case tdisotransmat:{
if (Mesprt==1) fprintf (stdout,"\n number of time dependent isotropic material models %ld",numt);
tditrm = new tdisotrmat [numt];
for (j=0;j<numt;j++){
k=numt+1;
xfscanf (in,"%ld",&k);
if (k>numt || k<1){
print_err("wrong number of time dependent isotropic material is required",__FILE__,__LINE__,__func__);
}
tditrm[k-1].read (in);
}
break;
}
case interfacem:{
if (Mesprt==1) fprintf (stdout,"\n number of material models for interface elements %ld",numt);
ifacemat = new interfacematt [numt];
1941,6 → 1963,10
ditrm[numinst].print (out);
break;
}
case tdisotransmat:{
tditrm[numinst].print (out);
break;
}
 
case interfacem:{
ifacemat[numinst].print (out);
2249,6 → 2275,7
case isotransmat:
case nlisotransmat:
case discontisotrmat:
case tdisotransmat:
case interfacem:
case cernyconcrete:
case bazantpedersen:
3607,6 → 3634,9
case isotransmat:{
break;
}
case tdisotransmat:{
break;
}
case nlisotransmat:{
break;}
case homomat:{
4076,6 → 4106,7
case homomat:
case damisotransmat:
case discontisotrmat:
case tdisotransmat:
case interfacem:
case cernyconcrete:
case bazantpedersen:
4347,6 → 4378,7
case homomat:
case damisotransmat:
case discontisotrmat:
case tdisotransmat:
case interfacem:
case cernyconcrete:
case bazantpedersen:
4445,6 → 4477,7
case homomat:
case damisotransmat:
case discontisotrmat:
case tdisotransmat:
case interfacem:
case cernyconcrete:
case bazantpedersen:
4632,6 → 4665,7
switch (ip[ipp].tm){
case isotransmat:
case tdisotransmat:
case homomat:
//here must be completeted
case damisotransmat:
4762,6 → 4796,7
case homomat:
case damisotransmat:
case discontisotrmat:
case tdisotransmat:
case interfacem:
case cernyconcrete:
case bazantpedersen:
/trunk/SIFEL/TRFEL/SRC/transmat.h
7,6 → 7,7
#include "selection.h"
#include "intpointst.h"
#include "isotrmat.h"
#include "tdisotrmat.h"
#include "sejtkrmat.h"
#include "nlisotrmat.h"
#include "cerny_concrete.h"
352,7 → 353,8
// one-phase medium - moisture transfer
// isotropic material with optional influence of damage
damisotrmat *damitrm;
// time dependent isotropic diffusion
tdisotrmat *tditrm;
// material for contact elements
interfacematt *ifacemat;
/trunk/SIFEL/TRFEL/SRC/twomedia.cpp
50,6 → 50,10
Tm->hommat[i].matcond(d,ri,ci,ipp);
break;
}
case tdisotransmat:{
Tm->tditrm[i].matcond(d,ri,ci,ipp);
break;
}
case damisotransmat:{
Tm->damitrm[i].matcond(d,ri,ci,ipp);
break;
133,6 → 137,9
case isotransmat:{
break;
}
case tdisotransmat:{
break;
}
case nlisotransmat:{
break;
}
229,6 → 236,10
Tm->hommat[i].matcap(c,ri,ci,ipp);
break;
}
case tdisotransmat:{
Tm->tditrm[i].matcap(c,ri,ci,ipp);
break;
}
case damisotransmat:{
Tm->damitrm[i].matcap(c,ri,ci,ipp);
break;