output.cpp

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

    for (j = 0, et = elemtype(-1); j < nprop; j++)
    // loop over all properties from input
    {
      // test if number of property matchs number from input
      if ((Top->E[i].property == Nep[j]) && (Sel[j] == Top->E[i].type))
      {
        if (Tel[j] >= 0)
        // assigning element type
        {
          et = Tel[j];
          ssst = Ssse[j];
          break;
        }
      }
    }
    if (et < 0)
    {
      fprintf(stderr, "\nError - element number %ld hasn't assigned type\n", i+1);
      for (k = 0; k < Top->elements; k++)
      {
        delete [] me[k]; delete [] mi[k]; delete [] im[k];
      }
      delete [] me; delete [] mi; delete [] nm;
      delete [] ce; delete [] ci; delete [] ic;
      return(1);
    }
    for (j = 0; j < nprop; j++)
    // loop over all properties from input
    {
      if (Ecs[j])
      // assigning cross-section to the element with number i
      {
        ce[i] = Ecs[j];
        ci[i] = Ecsi[j];
      }
    }
    if (ce[i] > 0)
    {
      if ((ic[i] = Dbcrs->search_crs(ce[i], ci[i]-1)) < 0)
      {
        fprintf(stderr, "\nError - cross-section with number %d and index %ld not found\n", ce[i], ci[i]);
        delete [] ce; delete [] ci; delete [] ic;
        return(1);
      }
      else
      {
        if (Dbcrs->crs[ic[i]].propu[ci[i]-1] == 0)
          Dbcrs->crs[ic[i]].npropu++; // indicator whether given cs type is used
        if (Ncu[ic[i]] == 0)
          Ncu[ic[i]]++; // indicator whether cs type from cs database is used in the given task
        Dbcrs->crs[ic[i]].propu[ci[i]-1]++;  // indicator whether given cs index is used
      }
    }
    for (j = 0; j < Dbcrs->numt; j++)
    {
      if (Dbcrs->crs[j].npropu)
      {
        rindex = 1;
        for (k = 0; k < Dbcrs->crs[j].nprop; k++)
        {
          if (Dbcrs->crs[j].propu[k])
          {
            if (Dbcrs->crs[j].ridx[k] != 0)
              rindex++;
          }
        }
        for (k = 0; k < Dbcrs->crs[j].nprop; k++)
        {
          if (Dbcrs->crs[j].propu[k])
          {
            if (Dbcrs->crs[j].ridx[k] == 0)
	    {
              Dbcrs->crs[j].ridx[k] = rindex;
              rindex++;
	    }
          }
        }
      }
    }
    nm[i] = 0;
    for (j = 0; j < nprop; j++)
    // loop over all properties from input
    {
      // test if number of property matchs number from input
      if (Top->E[i].property == Nep[j])
      {
        if (Mel[j])
        // assigning matrial to the element with number i
        {
          nm[i] = Nmel[j];
          me[i] = new mattype[Nmel[j]];
          mi[i] = new long[Nmel[j]];
          im[i] = new long[Nmel[j]];
          for (k = 0; k < Nmel[j]; k++)
          {
            me[i][k] = Mel[j][k];
            mi[i][k] = Melid[j][k];
          }
        }
      }
    }
    if (me[i] ==  NULL) // unassigned element material
    {
      fprintf(stderr, "\nError - element %ld hasn't assigned material\n", i+1);
      for (k = 0; k < Top->elements; k++)
      {
        delete [] me[k]; delete [] mi[k]; delete [] im[k];
      }
      delete [] me; delete [] mi; delete [] nm;
      return(1);
    }
    for (j = 0; j < nm[i]; j++)
    {
      // searching element material in the material database
      if ((im[i][j] = Dbmat->search_mat(me[i][j], mi[i][j]-1)) < 0)
      {
        fprintf(stderr,
                "\nError - material with number %d and index %ld not found\n", me[i][j], mi[i][j]);
        for (k = 0; k < Top->elements; k++)
        {
          delete [] me[k]; delete [] mi[k]; delete [] im[k];
        }
        delete [] me; delete [] mi; delete [] nm;
        return(1);
      }
      else
      {
        if (Dbmat->mat[im[i][j]].propu[mi[i][j]-1] == 0)
          Dbmat->mat[im[i][j]].npropu++; // indicator whether given material type is used
        if (Nmu[im[i][j]] == 0)
          Nmu[im[i][j]]++;  // indicator whether material type from material database is used in the given task
        Dbmat->mat[im[i][j]].propu[mi[i][j]-1]++; // indicator whether given material index is used
      }
    }
    for (j = 0; j < Dbmat->numt; j++)
    {
      if (Dbmat->mat[j].npropu)
      {
        rindex = 1;
        for (k = 0; k < Dbmat->mat[j].nprop; k++)
        {
          if (Dbmat->mat[j].propu[k])
          {
            if (Dbmat->mat[j].ridx[k] != 0)
              rindex++;
          }
        }
        for (k = 0; k < Dbmat->mat[j].nprop; k++)
        {
          if (Dbmat->mat[j].propu[k])
          {
            if (Dbmat->mat[j].ridx[k] == 0)
	    {
              Dbmat->mat[j].ridx[k] = rindex;
              rindex++;
	    }
          }
        }
      }
    }
    tip = 0;
    switch (et)  // determining number of integration points on the element and
                 //  whether ip needs cross-section
    {
      case beam2d:
      {
        tip = 1;
        break;
      }
      default :
        break;
    }
    if ((tip) && (ce[i] == 0))
    {
      fprintf(stderr, "\nError - element %ld hasn't assigned cross-section\n", i+1);
      delete [] ce; delete [] ci; delete [] ic;
      return(3);
    }

    for (ln = 0; ln < Nlay; ln++)
    {
      Mt->elements[i].te = et;
//      Top->E[i].type = et;

      // writing type of element, element number
      fprintf(out, "%6ld ", Nlay*i+ln+1);
      if ((et >= planeelementlt) && (et <= planeelementsubqt))
        fprintf(out, "%3d %3d", et, ssst);
      else
        fprintf(out, "%3d", et);
      Tet[i] = et;
      // writing element nodes
      for (j = 0; j < Top->E[i].size; j++)
      {
/*        if ((et == planeelementqt) && (d->t3d) && (j == 3))
        // nodes in T3d file has in this case folowing order 1 2 3 5 6 4 in view of
        // SIFEL order 1 2 3 4 5 6
          continue;*/
        fprintf(out, " %6ld", (Top->E[i].node[j]-1)*Nlay+ln+1);
      }
/*      if ((et == planeelementqt) && (d->t3d))
      // nodes in T3d file has in this case folowing order 1 2 3 5 6 4 in view of
      // SIFEL order 1 2 3 4 5 6
      // so it is need to write fourth node
        fprintf(out, " %6ld", Top->E[i].node[3]);*/

      // no code numbers on element (code numbers not supported at this time)
      fprintf(out, " 0");
      if (ce[i] > 0)
        fprintf(out, " %d %ld", ce[i], Dbcrs->crs[ic[i]].ridx[ci[i]-1]); // if element has cs, write cs type and index
      else
        fprintf(out, " 0"); // writing element cross-section indicator
      fprintf(out, " %ld", nm[i]);  
      for (l = 0; l < nm[i]; l++)
        fprintf(out, " %d %ld", me[i][l], Dbmat->mat[im[i][l]].ridx[mi[i][l]-1]); // writing element material type and index
      fprintf(out, "\n");
    }
  }
  fprintf(out, "\n");
  for (k = 0; k < Top->elements; k++)
  {
    delete [] me[k];
    delete [] mi[k];
    delete [] im[k];
  }
  delete [] me; delete [] mi; delete [] nm;
  delete [] ce; delete [] ci; delete [] ic;
  return(0);
}



/**<
 Function writes section with description of elements to the text file given by out.

 @param out - pointer to the opened text file, where the data will be written

 @retval 0 : on succes
*/
long wr_globnodnum(FILE *out)
{
  for (long i = 0; i < Top->nodes; i++)
    fprintf(out, "%ld\n", Top->Pn[i]);
  return(0);
}

/**
 Function writes section with description of elements to the text file given by out.

  @param out - pointer to the opened text file, where the data will be written
  @param nprop - number of entries in the input property file

  @retval 0 : if succes
  @retval 1 : if element hasn't assigned material
  @retval 2 : if element hasn't assigned type
  @retval 3 : if element hasn't assigned cross-section
*/
long wr_intpoints(FILE *out, long nprop)
{
/*  long i, j, k, l;
  mattype **me;
  long **mi, **im, *nm;
  elemtype et = elemtype(-1);
  long rindex;

  me   = new mattype* [Top->elements];
  memset(me, 0, sizeof(*me)*Top->elements);
  mi   = new long* [Top->elements];
  memset(mi, 0, sizeof(*mi)*Top->elements);
  im   = new long* [Top->elements];
  memset(im, 0, sizeof(*im)*Top->elements);
  nm   = new long  [Top->elements];
  Enip = new long  [Top->elements];
  memset(Enip, 0, sizeof(*Enip)*Top->elements);

//  Nmu = 0;
  for (i = 0; i < Top->elements; i++)
  {
    nm[i] = 0;
    for (j = 0; j < nprop; j++)
    // loop over all properties from input
    {
      // test if number of property matchs number from input
      if (Top->E[i].property == Nep[j])
      {
        if (Mel[j])
        // assigning matrial to the element with number i
        {
          nm[i] = Nmel[j];
          me[i] = new mattype[Nmel[j]];
          mi[i] = new long[Nmel[j]];
          im[i] = new long[Nmel[j]];
          for (k = 0; k < Nmel[j]; k++)
          {
            me[i][k] = Mel[j][k];
            mi[i][k] = Melid[j][k];
          }
        }
      }
    }
    et = Tet[i];
    if (et < 0) // unassigned element type
    {
      fprintf(stderr, "\nError - element %ld hasn't assigned type\n", i+1);
      for (k = 0; k < Top->elements; k++)
      {
        delete [] me[k]; delete [] mi[k]; delete [] im[k];
      }
      delete [] me; delete [] mi; delete [] nm;
      return(1);
    }
    if (me[i] ==  NULL) // unassigned element material
    {
      fprintf(stderr, "\nError - element %ld hasn't assigned material\n", i+1);
      for (k = 0; k < Top->elements; k++)
      {
        delete [] me[k]; delete [] mi[k]; delete [] im[k];
      }
      delete [] me; delete [] mi; delete [] nm;
      return(1);
    }


    for (j = 0; j < nm[i]; j++)
    {
      // searching element material in the material database
      if ((im[i][j] = Dbmat->search_mat(me[i][j], mi[i][j]-1)) < 0)
      {
        fprintf(stderr,
                "\nError - material with number %d and index %ld not found\n", me[i][j], mi[i][j]);
        for (k = 0; k < Top->elements; k++)
        {
          delete [] me[k]; delete [] mi[k]; delete [] im[k];
        }
        delete [] me; delete [] mi; delete [] nm;
        return(1);
      }
      else
      {
        if (Dbmat->mat[im[i][j]].propu[mi[i][j]-1] == 0)
          Dbmat->mat[im[i][j]].npropu++; // indicator whether given material type is used
        if (Nmu[im[i][j]] == 0)
          Nmu[im[i][j]]++;  // indicator whether material type from material database is used in the given task
        Dbmat->mat[im[i][j]].propu[mi[i][j]-1]++; // indicator whether given material index is used
      }
    }
    Enip[i] = Mt->give_nip(i,0);
  }
  for (j = 0; j < Dbmat->numt; j++)
  {
    if (Dbmat->mat[j].npropu)
    {
      rindex = 1;
      for (k = 0; k < Dbmat->mat[j].nprop; k++)
      {
        if (Dbmat->mat[j].propu[k])
        {
          Dbmat->mat[j].ridx[k] = rindex;
          rindex++;
        }
      }
    }
  }
  for (i = 0; i < Top->elements; i++)
  {
    for (k = 0; k < Enip[i]; k++)
    {
      for (l = 0; l < nm[i]; l++)
        fprintf(out, "%d %ld ", me[i][l], Dbmat->mat[im[i][l]].ridx[mi[i][l]-1]); // writing element material type and index
      fprintf(out, "\n");
    }
    fprintf(out, "\n");
  }
  fprintf(out, "\n");
  for (k = 0; k < Top->elements; k++)
  {
    delete [] me[k];
    delete [] mi[k];
    delete [] im[k];
  }
  delete [] me; delete [] mi; delete [] nm;*/
  return(0);
}



/**
 Function writes materials and thier parameters to the file given by the out.

  @param out - pointer to the opened text file, where the data will be written

  @retval 0 : on succes
*/
long wr_materials(FILE *out)
{
  long i, j, nmtu, wrt;
  for (i = 0, nmtu = 0; i < Dbmat->numt; i++)
  // countig number of used material types
  {
    if (Nmu[i])
      nmtu++;
  }
  fprintf(out, "%ld\n", nmtu);  // writing number of material types
  for (i = 0; i < Dbmat->numt; i++)
  {
    wrt = 1;
    for (j = 0; j < Dbmat->mat[i].nprop; j++)
    {
      if (Dbmat->mat[i].propu[j])  // material type index is used (<> 0)
      {
        if (wrt)  // for the first time write material type number and number of used indeces
        {
          fprintf(out, "%d %ld\n", Dbmat->mat[i].type, Dbmat->mat[i].npropu);
          wrt = 0;  // next time don't write
        }
        // write material type index and property string
        fprintf(out, "%ld %s\n", Dbmat->mat[i].ridx[j], Dbmat->mat[i].prop[j]);
      }
    }
  }
  fprintf(out, "\n");
  return(0);
}



long wr_auxpoint(FILE *out, long nprop)
{
  long i, j, k, n, psn = 0;
  n = Nlay;
  if (n == 0)
    n = 1;
  for (i = 0; i < Top->elements; i++)
  {
    for (k = 0; k < n; k++)
    {
      for (j = 0; j < nprop; j++)
      {
        if ((Top->E[i].property == Nep[j]) && (Sel[j] == Top->E[i].type))
        {
          if (Eep[j] >= 0)
          {
            fprintf(out, "%d", Eep[j]);
            if (Eps[j])
            {
              psn++;
              Eps[j]->n = psn;
              fprintf(out, " %ld", psn);
            }
            fprintf(out,"\n");
            break;
          }
        }
      }
    }
  }
  if (psn != 0)
    fprintf(out, "%ld\n", psn);
  for (j = 0; j < nprop; j++)
  {
    if (Eps[j])
      Eps[j]->print(out);
  }
  fprintf(out, "\n");
  return(0);
}



/**
 Function writes section with local coordinate systems in points on elements
 to the text file given by out.

  @param out - pointer to the opened text file, where the data will be written
  @param nprop - number of entries in the input property file

  @retval 0 : if succes
*/
long wr_ellcsys(FILE *out, long nprop)
{
  long i, j, k, n, nl;
  long *elsvi = NULL, telsvi = 0, nells = 0;
  long ips;
  pointset    *tps;
  elemposition tep;

  elsvi = new long[nprop];
  memset(elsvi, 0, sizeof(*elsvi)*nprop);