mechcrsec.cpp

Finite element program for mechanical problem. It can solve various problem in solid problem

#include "mechcrsec.h"
#include "global.h"
#include "matrix.h"
#include "vector.h"
#include "crsec2dbar.h"
#include "crsecplstr.h"
#include "crsec2dbeam.h"
#include "crsec3dbeam.h"
#include "crsec3d.h"
#include "crsecnod.h"
#include "element.h"
#include "node.h"

mechcrsec::mechcrsec ()
{
  ncst=0;
  cs2dbar=NULL;
  cs2dbeam=NULL;
  cs3dbeam=NULL;
  csplstr=NULL;
  cs3d=NULL;
  csnod=NULL;
}
mechcrsec::~mechcrsec ()
{
  delete [] cs2dbar;
  delete [] cs2dbeam;
  delete [] cs3dbeam;
  delete [] csplstr;
  delete [] cs3d;
  delete [] csnod;
}

/**
   function reads cross section characteristics

   @param in - input stream

   22.7.2001
*/
void mechcrsec::read (XFILE *in)
{
  long i,j,k,numtype;
  crsectype cstype;

  xfscanf (in,"%k%ld","number_of_cross_section_types",&ncst);
  if (ncst<0){
    fprintf (stderr,"\n\n negative number of cross-sections in function crsec::read (file %s, line %d).\n",__FILE__,__LINE__);
  }
  
  for (i=0;i<ncst;i++){
    xfscanf (in,"%d %ld",(int*)&cstype,&numtype);
    if (numtype<1){
      fprintf (stderr,"\n\n negative number of cross-section in function crsec::read (file %s, line %d).\n",__FILE__,__LINE__);
    }
    
    switch (cstype){
    case nocrosssection:{
      break;
    }
    case csbar2d:{
      cs2dbar = new crsec2dbar [numtype];
      for (j=0;j<numtype;j++){
	xfscanf (in,"%ld",&k);
	if (k<1){}
	if (k>numtype){}
	cs2dbar[k-1].read (in);
      }
      break;
    }
    case csbeam2d:{
      cs2dbeam = new crsec2dbeam [numtype];
      for (j=0;j<numtype;j++){
	xfscanf (in,"%ld",&k);
	if (k<1){}
	if (k>numtype){}
	cs2dbeam[k-1].read (in);
      }
      break;
    }
    case csbeam3d:{
      cs3dbeam = new crsec3dbeam [numtype];
      for (j=0;j<numtype;j++){
	xfscanf (in,"%ld",&k);
	if (k<1){}
	if (k>numtype){}
	cs3dbeam[k-1].read (in);
      }
      break;
    }
    case csplanestr:{
      csplstr = new crsecplstr [numtype];
      for (j=0;j<numtype;j++){
	xfscanf (in,"%ld",&k);
	if (k<1){}
	if (k>numtype){}
	csplstr[k-1].read (in);
      }
      break;
    }
    case cs3dprob:{
      cs3d = new crsec3d [numtype];
      for (j=0;j<numtype;j++){
	xfscanf (in,"%ld",&k);
	if (k<1){}
	if (k>numtype){}
	cs3d[k-1].read (in);
      }
      break;
    }
    case csnodal:{
      csnod = new crsecnod [numtype];
      for (j=0;j<numtype;j++){
	xfscanf (in,"%ld",&k);
	if (k<1){}
	if (k>numtype){}
	csnod[k-1].read (in);
      }
      break;
    }
    default:{
      fprintf (stderr,"\n\n unknown cross section type is required in function");
      fprintf (stderr,"\n crsec::read (file %s, line %d).\n",__FILE__,__LINE__);
    }
    }
  }
}

/**
   function returns thicknesses in nodes
   
   @param nod - vector containing numbers of nodes defining element
   @param t - array containing thicknesses
   
   22.7.2001
*/
void mechcrsec::give_thickn (ivector &nod,vector &t)
{
  long i,n;
  n=nod.n;
  for (i=0;i<n;i++){
    switch (Mt->nodes[nod[i]].crst){
    case nocrosssection:{
      break;
    }
    case csbar2d:{
      break;
    }
    case csbeam2d:{
      break;
    }
    case csbeam3d:{
      break;
    }
    case csplanestr:{
      t[i]=csplstr[Mt->nodes[nod[i]].idcs].t;
      break;
    }
    default:{
      fprintf (stderr,"\n\n unknown cross section type is required in function");
      fprintf (stderr,"\n mechcrsec::give_thick (file %s, line %d).\n",__FILE__,__LINE__);
    }
    }
  }
}

/**
   function returns thickness on element
   
   22.7.2001
*/
void mechcrsec::give_thicke (long eid,double &t)
{
  switch (Mt->elements[eid].crst){
  case nocrosssection:{
    break;
  }
  case csbar2d:{
    break;
  }
  case csbeam2d:{
    break;
  }
  case csbeam3d:{
    break;
  }
  case csplanestr:{
    t=csplstr[Mt->elements[eid].idcs].t;
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown cross section type is required in function");
    fprintf (stderr,"\n mechcrsec::give_thick (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
}


void mechcrsec::give_thickness (long eid,ivector &nodes,vector &th)
{
  long i,nne;
  double t;
  
  if (Mt->elements[eid].crst==0){
    give_thickn (nodes,th);
  }
  else{
    give_thicke (eid,t);
    nne = Mt->give_nne (eid);
    for (i=0;i<nne;i++){
      th[i]=t;
    }
  }
}

double mechcrsec::give_onethickness (crsectype crst,long idcs)
{
  double t;
  
  switch (crst){
  case nocrosssection:{
    break;
  }
  case csbar2d:{
    break;
  }
  case csbeam2d:{
    t=cs2dbeam[idcs].t;
    break;
  }
  case csbeam3d:{
    break;
  }
  case csplanestr:{
    t=csplstr[idcs].t;
    break;
  }
  case csnodal:{
    t=csnod[idcs].t;
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown cross section type is required in function");
    fprintf (stderr,"\n mechcrsec::give_onethickness (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
  
  return t;
}

/**
   function returns area of cross-section
   
   @param eid - element id

   10.8.2001
*/
void mechcrsec::give_area (long eid,double &a)
{
  switch (Mt->elements[eid].crst){
  case nocrosssection:{
    break;
  }
  case csbar2d:{
    a=cs2dbar[Mt->elements[eid].idcs].a;
    break;
  }
  case csbeam2d:{
    a=cs2dbeam[Mt->elements[eid].idcs].a;
    break;
  }
  case csbeam3d:{
    a=cs3dbeam[Mt->elements[eid].idcs].a;
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown cross section type is required in function");
    fprintf (stderr,"\n mechcrsec::give_area (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
}

/**
   function returns moment(s) of inertia of cross-section
   
   @param eid - element id
   @param i - array containing moments of inertia
   
   10.8.2001
*/
void mechcrsec::give_mominer (long eid,double *i)
{
  switch (Mt->elements[eid].crst){
  case nocrosssection:{
    break;
  }
  case csbeam2d:{
    //*i=cs2dbeam[Mt->elements[eid].idcs].iy;
    cs2dbeam[Mt->elements[eid].idcs].give_moments (i);
    break;
  }
  case csbeam3d:{
    cs3dbeam[Mt->elements[eid].idcs].give_moments (i);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown cross section type is required in function");
    fprintf (stderr,"\n mechcrsec::give_mominer (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
}

/**
   function returns shear coefficient(s) of cross-section

   shear coefficient for rectangle is 5/6
   
   @param eid - element id
   @param shearcoeff - array containing shear coefficients
   
   10.8.2001
*/
void mechcrsec::give_shearcoeff (long eid,double *shearcoeff)
{
  switch (Mt->elements[eid].crst){
  case nocrosssection:{
    break;
  }
  case csbeam2d:{
    //*shearcoeff=cs2dbeam[Mt->elements[eid].idcs].shearcoeff;
    cs2dbeam[Mt->elements[eid].idcs].give_shearcoeff (shearcoeff);
    break;
  }
  case csbeam3d:{
    cs3dbeam[Mt->elements[eid].idcs].give_shearcoeff (shearcoeff);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown cross section type is required in function");
    fprintf (stderr,"\n mechcrsec::give_kappa (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
}
/**
   function returns shear vector axis [z] cross-section

   shear coefficient for rectangle is 5/6
   
   @param eid - element id
   @param shearcoeff - array containing shear coefficients
   
   10.8.2001
*/
void mechcrsec::give_vectorlcs (long eid,vector &vec)
{
  switch (Mt->elements[eid].crst){
  case csbeam3d:{
    copyv(cs3dbeam[Mt->elements[eid].idcs].lcs,vec);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown cross section type is required in function");
    fprintf (stderr,"\n mechcrsec::give_kappa (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
}

/**
   function returns densities in nodes
   
   @param nod - vector containing numbers of nodes defining element
   @param rho - array containing densities
   
   22.7.2001
*/
void mechcrsec::give_densityn (ivector &nod,vector &rho)
{
  long i,n;
  n=nod.n;
  for (i=0;i<n;i++){
    switch (Mt->nodes[nod[i]].crst){
    case nocrosssection:{
      break;
    }
    case csbar2d:{
      break;
    }
    case csbeam2d:{
      break;
    }
    case csbeam3d:{
      break;
    }
    case csplanestr:{
      rho[i]=csplstr[Mt->nodes[nod[i]].idcs].rho;
      break;
    }
    case cs3dprob:{
      rho[i]=cs3d[Mt->nodes[nod[i]].idcs].rho;
      break;
    }
    default:{
      fprintf (stderr,"\n\n unknown cross section type is required in function");
      fprintf (stderr,"\n mechcrsec::give_densityn (file %s, line %d).\n",__FILE__,__LINE__);
    }
    }
  }
}

/**
   function returns densities on element
   
   @param eid - element id
   @param rho - density
   
   10.8.2001
*/
void mechcrsec::give_densitye (long eid,double &rho)
{
  switch (Mt->elements[eid].crst){
  case nocrosssection:{
    break;
  }
  case csbar2d:{
    rho=cs2dbar[Mt->elements[eid].idcs].rho;
    break;
  }
  case csbeam2d:{
    rho=cs2dbeam[Mt->elements[eid].idcs].rho;
    break;
  }
  case csbeam3d:{
    rho=cs3dbeam[Mt->elements[eid].idcs].rho;
    break;
  }
  case cs3dprob:{
    rho=cs3d[Mt->elements[eid].idcs].rho;
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown cross section type is required in function");
    fprintf (stderr,"\n mechcrsec::give_densitye (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
}

void mechcrsec::give_density (long eid,ivector &nodes,vector &dens)
{
  long i,nne;
  double d;
  
  if (Mt->elements[eid].crst==0){
    give_densityn (nodes,dens);
  }
  else{
    give_densitye (eid,d);
    nne = Mt->give_nne (eid);
    for (i=0;i<nne;i++){
      dens[i]=d;
    }
  }
}

/**
   function returns weight of concentrated mass
   
   @param cr - type of cross section
   @param idcs - number of cross section
   
   JK, 25.7.2005
*/
double mechcrsec::give_weight (crsectype cr,long idcs)
{
  double m;
  
  switch (cr){
  case nocrosssection:{
    break;
  }
  case csbar2d:{
    break;
  }
  case csbeam2d:{
    break;
  }
  case csbeam3d:{
    break;
  }
  case csplanestr:{
    m=csplstr[idcs].m;
    break;
  }
  case csnodal:{
    m=csnod[idcs].m;
  }
  default:{
    fprintf (stderr,"\n\n unknown cross section type is required in function");
    fprintf (stderr,"\n mechcrsec::give_weight (file %s, line %d).\n",__FILE__,__LINE__);
  }
  }
  
  return m;
}