mechprint.cpp

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

          break;
        default :
          fprintf(stderr, "\n\n Error - unknown direction of strain");
          fprintf(stderr, "\n in function write_gid_nodscalar, file %s, line %d\n", __FILE__, __LINE__);
      }
    }
    if (Mt->nodes[0].ncompstr == 6)
    {
      switch (dir)
      {
        case 0:
          sig = "eps_n_x";
          break;
        case 1:
          sig = "eps_n_y";
          break;
        case 2:
          sig = "eps_n_z";
          break;
        case 3:
          sig = "eps_n_yz";
          break;
        case 4:
          sig = "eps_n_xz";
          break;
        case 5:
          sig = "eps_n_xy";
          break;
        default :
          fprintf(stderr, "\n\n Error - unknown direction of strain");
          fprintf(stderr, "\n in function write_gid_nodscalar, file %s, line %d\n", __FILE__, __LINE__);
      }
    }
  }
  if (scal == pstress)
  {
    switch (dir)
    {
      case 0:
        sig = "psig_n_1";
        break;
      case 1:
        sig = "psig_n_2";
        break;
      case 2:
        sig = "psig_n_3";
        break;
      case 3:
        sig = "tau_n_max";
        break;
      default:
        fprintf(stderr, "\n\n Error - unknown direction of principal stress");
        fprintf(stderr, "\n in function write_gid_nodscalar, file %s, line %d\n", __FILE__, __LINE__);
    }
  }
  if (scal == pstrain)
  {
    switch (dir)
    {
      case 0:
        sig = "peps_n_1";
        break;
      case 1:
        sig = "peps_n_2";
        break;
      case 3:
        sig = "peps_n_3";
        break;
      default:
        fprintf(stderr, "\n\n Error - unknown direction of principal strains");
        fprintf(stderr, "\n in function write_gid_nodscalar, file %s, line %d\n", __FILE__, __LINE__);
    }
  }
  if (scal == other)
    fprintf(out, "\nResult \"other_n_%ld\" \"%ld\" %s Scalar OnNodes\n", dir+1, lcid, desclcid);
  else     
    fprintf(out, "\nResult \"%s\" \"%ld\" %s Scalar OnNodes\n", sig, lcid, desclcid);
  fprintf(out, "Values\n");
  switch (scal)
  {
    case stress :
      for (i = 0; i < Mt->nn; i++)
      {
        // checking required scalar type and selection of the node and selection of the component
        if (Outdm->nog.selnstre.presence_id(Outdm->nog.selstre, i, dir) == 0)
          continue;
        ncompstr = Mt->nodes[i].ncompstr;
        fprintf(out, "%ld % e\n", i+Outdm->idn1, Mt->nodes[i].stress[ncompstr*lcid+dir]);
      }
      break;
    case strain :
      for (i = 0; i < Mt->nn; i++)
      {
        // checking required scalar type and selection of the node and selection of the component
        if (Outdm->nog.selnstra.presence_id(Outdm->nog.selstra, i, dir) == 0)
          continue;
        ncompstr = Mt->nodes[i].ncompstr;
        fprintf(out, "%ld % e\n", i+Outdm->idn1, Mt->nodes[i].strain[ncompstr*lcid+dir]);
      }
      break;
    case pstress :
      for (i = 0; i < Mt->nn; i++)
      {
        if (Mt->nodes[i].pstre == NULL)
          continue;
        // checking required scalar type and selection of the node and selection of the component
        if (Outdm->nog.selnstre.presence_id(Outdm->nog.selstre, i, dir) == 0)
          continue;
        if (dir == 3)
          fprintf(out, "%ld % e\n", i+Outdm->idn1, (Mt->nodes[i].pstre[3*lcid]+Mt->nodes[i].pstre[3*lcid+2])/2);
        else
          fprintf(out, "%ld % e\n", i+Outdm->idn1, Mt->nodes[i].pstre[3*lcid+dir]);
      }
      break;
    case pstrain :
      for (i = 0; i < Mt->nn; i++)
      {
        // checking required scalar type and selection of the node and selection of the component
        if (Outdm->nog.selnstra.presence_id(Outdm->nog.selstra, i, dir) == 0)
          continue;
        ncompstr = Mt->nodes[i].ncompstr;
        fprintf(out, "%ld % e\n", i+Outdm->idn1, Mt->nodes[i].pstra[3*lcid+dir]);
      }
      break;
    case other :
      for (i = 0; i < Mt->nn; i++)
      {
        // checking required scalar type and selection of the node and selection of the component
        if (Outdm->nog.selnoth.presence_id(Outdm->nog.seloth, i, dir) == 0)
          continue;
        ncompother = Mt->nodes[i].ncompother;
        fprintf(out, "%ld % e\n", i+Outdm->idn1, Mt->nodes[i].other[ncompother*lcid+dir]);
      }
      break;
    default :
      fprintf(stderr, "\n\n Error - unknown value type in function write_gid_nodscalar()\n");
      fprintf(stderr, "  in file %s, line %d\n", __FILE__, __LINE__);
  }
  fprintf(out, "End Values\n");
}

/**
  The function writes a scalar quantity given by parameters scal and dir on all elements to the file given by parameter out in GiD format. 
  The results are printed at each integration point on given element.

  Parameters :
  @param out - pointer to the opened text file where the output will be produced
  @param scal - specifies type of required scalar quantity (strain/stres/other)
  @param lcid - load case id
  @param dir - specifies which component of the quantity array will be printed
  @param desclcid - string with description of loadcase

  Return :
  The function does not return anything
*/
void write_gid_elemscalar(FILE *out, strastre scal, long lcid, long dir, char *desclcid)
{
  if (Bar2d)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, bar2d);

  if (Bar3d)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, bar3d);

  if (Barq2d)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, barq2d);

  if (Beam2d)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, beam2d);

  if (Beam3d)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, beam3d);

  if (Sbeam)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, subsoilbeam);

  if (Spring)
  {
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, spring_1);
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, spring_2);
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, spring_3);
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, spring_4);
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, spring_5);
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, spring_6);
  }

  if (Pelt)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, planeelementlt);

  if (Peqt)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, planeelementqt);

  if (Perlt)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, planeelementrotlt);

  if (Pelq)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, planeelementlq);

  if (Peqq)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, planeelementqq);

  if (Perlq)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, planeelementrotlq);

  if (Pesqt)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, planeelementsubqt);

  if (Cct)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, cctel);

  if (Dkt)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, dktel);

  if (Dst)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, dstel);

  if (Q4pl)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, q4plateel);

  if (Spltr)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, subsoilplatetr);

  if (Splq)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, subsoilplateq);

  if (Asymlq)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, axisymmlt);

  if (Asymlt)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, axisymmlq);

  if (Asymqq)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, axisymmqq);

  if (Shtr)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, shelltrelem);

  if (Shq)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, shellqelem);

  if (Ltet)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, lineartet);

  if (Lhex)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, linearhex);

  if (Qhex)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, quadrhex);

  if (Lwed)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, linearwed);

  if (Qwed)
    write_gid_elem_type_scalar(out, scal, lcid, dir, desclcid, quadrwed);
}

/**
  The function writes a scalar value given by parameter scal on elements of given type (parameter te)
  to the file given by parameter out in GiD format. The results are printed at each  element integration 
  points.

  Parameters :
  @param out - pointer to the opened text file where the output will be produced
  @param scal - specifies type of required scalar quantity (strain/stres/other)
  @param lcid - load case id
  @param dir - specifies which component of the quantity array will be printed
  @param desclcid - string with description of loadcase
  @param te - required element type

  Return :
  The function does not return anything
*/
void write_gid_elem_type_scalar(FILE *out, strastre scal, long lcid, long dir, char *desclcid, elemtype te)
{
  char *sig = "";
  char gpname[1000];
  long i, j, ipp,ncompstr,ncompother,tnip;
  long print_header = 1;


  for (i = 0; i < Mt->ne; i++)
  {
    if (Gtm->leso[i]==0)
      continue;

    tnip = Mt->give_totnip(i);
    if (te == planeelementlq)
      tnip = 4;

    // checking required element type
    if (Mt->elements[i].te != te)
      continue; 

    // checking required scalar type and selection of the element and selection of the component
    if ((scal == strain) && (Outdm->eog.selestra.presence_id(Outdm->eog.selstra, i, dir) == 0))
      continue;
    if ((scal == stress) && (Outdm->eog.selestre.presence_id(Outdm->eog.selstre, i, dir) == 0))
      continue;
    if ((scal == other) && (Outdm->eog.seleoth.presence_id(Outdm->eog.seloth, i, dir) == 0))
      continue;

    if (print_header)
    {
      ipp = Mt->elements[i].ipp[0][0];
      if (scal == stress)
      {
        switch (Mm->ip[ipp].ssst)
        {
          case bar:
            switch (dir)
            {
              case 0:
                sig = "sig_e_1";
                break;
              case 1:
                sig = "sig_e_2";
                break;
              case 2:
                sig = "sig_e_3";
                break;
              case 3:
                sig = "sig_e_4";
                break;
              case 4:
                sig = "sig_e_5";
                break;
              case 5:
                sig = "sig_e_6";
                break;
              default :
                fprintf(stderr, "\n\n Error - unknown direction of stress");
                fprintf(stderr, "\n in function  write_gid_elemscalar, file %s, line %d\n", __FILE__, __LINE__);
            }
            break;
          case plbeam:
            switch (dir)
            {
              case 0:
                sig = "N";
                break;
              case 1:
                sig = "V";
                break;
              case 2:
                sig = "M";
                break;
              default :
                fprintf(stderr, "\n\n Error - unknown direction of stress");
                fprintf(stderr, "\n in function  write_gid_elemscalar, file %s, line %d\n", __FILE__, __LINE__);
            }
            break;
          case planestress:
          case planestrain: 
            switch (dir)
            {
              case 0:
                sig = "sig_e_x";
                break;
              case 1:
                sig = "sig_e_y";
                break;
              case 2:
                sig = "tau_e_xy";
                break;
              case 3:
                sig = "sig_e_z";
                break;
              default :
                fprintf(stderr, "\n\n Error - unknown direction of stress");
                fprintf(stderr, "\n in function write_gid_elemscalar, file %s, line %d\n", __FILE__, __LINE__);        
            }
            break;
          case axisymm:
            switch (dir)
            {
              case 0:
                sig = "sig_e_r";
                break;
              case 1:
                sig = "sig_e_z";
                break;
              case 2:
                sig = "sig_e_phi";
                break;
              case 3:
                sig = "sig_e_rz";
                break;
              default :
                fprintf(stderr, "\n\n Error - unknown direction of stress");
                fprintf(stderr, "\n in function write_gid_elemscalar, file %s, line %d\n", __FILE__, __LINE__);        
	    }
            break;
          case spacestress:
            switch (dir)
            {
              case 0:
                sig = "sig_e_x";
                break;
              case 1:
                sig = "sig_e_y";
                break;
              case 2:
                sig = "sig_e_z";
                break;
              case 3:
                sig = "tau_e_yz";
                break;
              case 4:
                sig = "tau_e_xz";
                break;
              case 5:
                sig = "tau_e_xy";
                break;
              default :
                fprintf(stderr, "\n\n Error - unknown direction of stress");
                fprintf(stderr, "\n in function  write_gid_elemscalar, file %s, line %d\n", __FILE__, __LINE__);
            }
            break;
          default:
            fprintf(stderr, "\n\n Error - unknown stress/strain state is required");
            fprintf(stderr, "\n in function  write_gid_elemscalar, file %s, line %d\n", __FILE__, __LINE__);
        }
      }
      if (scal == strain)
      {
        switch (Mm->ip[ipp].ssst)
        {
          case bar:
            switch (dir)
            {
              case 0:
                sig = "eps_e_1";
                break;
              case 1:
                sig = "eps_e_2";
                break;
              case 2:
                sig = "eps_e_3";
                break;
              case 3:
                sig = "eps_e_4";
                break;
              case 4:
                sig = "eps_e_5";
                break;
              case 5:
                sig = "eps_e_6";
                break;
              default :
                fprintf(stderr, "\n\n Error - unknown direction of strain");
                fprintf(stderr, "\n in function  write_gid_elemscalar, file %s, line %d\n", __FILE__, __LINE__);
            }
	    break;
          case plbeam:
            switch (dir)
            {
              case 0:
                sig = "u";
                break;
              case 1: