outdiagm.cpp

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

#include <string.h>
#include "outdiagm.h"
#include "iotools.h"
#include "gtopology.h"
#include "global.h"
#include "probdesc.h"
#include "meshtransfer.h"
#include "mechtop.h"
#include "element.h"
#include "node.h"
#include "intpoints.h"
#include "globmat.h"

/**
  This constructor initializes data to zero values
*/
outdiagm::outdiagm()
{
  pid = NULL; eid = NULL; ipeid = NULL; nif = NULL;
  pu = NULL;
  ipu = NULL;
}


/**
  This destructor deallocates used memory
*/
outdiagm::~outdiagm()
{
  delete [] nif;
  delete [] pid;
  delete [] eid;
  delete [] ipeid;
  delete [] pu;
  delete [] ipu;
}



/** This function reads data from the file given by the pointer to the 
    opened text file.
   
    @param  in - pointer to the opened text file where the data will be read from

    @retval 0 - on success
    @retval 1 - in case read error   
*/
long outdiagm::read(XFILE *in)
{
  long i;
  if (xfscanf (in, "%k%ld", "numunknowns", &npun) != 2)
  {
    fprintf(stderr, "\n\nError reading number of printed unknowns\n");
    fprintf(stderr, " function outdiagm::read, (file %s, line %d)\n", __FILE__,__LINE__);
    return 1;
  }
  if (xfscanf (in, "%k%ld", "period", &pstep) != 2)
  {
    fprintf(stderr, "\n\nError reading number of print step\n");
    fprintf(stderr, " function outdiagm::read, (file %s, line %d)\n", __FILE__,__LINE__);
    return 1;
  }
  nif   = new nodip[npun];
  pid   = new long [npun];
  eid   = new long [npun];
  ipeid = new long [npun];
  pu    = new prunk[npun];
  ipu   = new long [npun];
  memset(nif, 0, sizeof(*nif)*npun);
  memset(pu, 0, sizeof(*pu)*npun);
  memset(ipu, 0, sizeof(*ipu)*npun);
  for (i=0; i<npun; i++)
  {
    pid[i] = eid[i] = ipeid[i] = -1;
    if (xfscanf (in, "%k%m", "point", &nodip_kwdset, (int *)(nif+i)) != 2)
    {
      fprintf(stderr, "\n\nError reading type of point\n");
      fprintf(stderr, " function outdiagm::read, (file %s, line %d)\n", __FILE__,__LINE__);
      return 1;
    }
    switch (nif[i])
    {
      case atnode:
        if (xfscanf (in, "%k%ld", "node", pid+i) != 2)
        {
          fprintf(stderr, "\n\nError reading node id\n");
          fprintf(stderr, " function outdiagm::read, (file %s, line %d)\n", __FILE__,__LINE__);
          return 1;
        }
        pid[i]--;
        break;
      case atip:
        if (xfscanf (in, "%k %ld %k %ld", "elem", eid+i, "ip", ipeid+i) != 4)
        {
          fprintf(stderr, "\n\nError reading element or ip number\n");
          fprintf(stderr, " function outdiagm::read, (file %s, line %d)\n", __FILE__,__LINE__);
          return 1;
        }
        eid[i]--; ipeid[i]--;
        break;
      case atxyz:
        if (xfscanf (in, "%k %le %k %le %k %le", "x", &x, "y", &y, "z", &z) != 6)
        {
          fprintf(stderr, "\n\nError point coordinates\n");
          fprintf(stderr, " function outdiagm::read, (file %s, line %d)\n", __FILE__,__LINE__);
          return 1;
        }
        pid[i] = adjacnode (Gtm,x,y,z);
        break;
      default:
        fprintf(stderr, "\n\nUnknown type of point is required in function outdiagm::read\n");
        fprintf(stderr, " (file %s, line %d)\n", __FILE__, __LINE__); 
        return 1;
    }
  
    if (xfscanf (in, "%k%m", "unknowntype", &prunk_kwdset, (int *)(pu+i)) != 2)
    {
      fprintf(stderr, "\n\nError reading type of printed unknown\n");
      fprintf(stderr, " function outdiagm::read, (file %s, line %d)\n", __FILE__,__LINE__);
      return 1;
    }
    if ((pu[i] == pr_stepid) || (pu[i] == pr_appload))
      continue;
    if (xfscanf (in, "%k%ld", "compid", ipu+i) != 2)
    {
      fprintf(stderr, "\n\nError reading type of printed unknown\n");
      fprintf(stderr, " function outdiagm::read, (file %s, line %d)\n", __FILE__,__LINE__);
      return 1;
    }
    ipu[i]--;
    if ((nif[i] == atnode) || (nif[i] == atxyz))
    {
      switch (pu[i])
      {
        case pr_strains :
          Mp->straincomp = 1;
          Mp->strainaver = 1;
          break;
        case pr_stresses :
          Mp->stresscomp = 1;
          Mp->stressaver = 1;
          break;
        case pr_react :
          Mp->reactcomp = 1;
          break;
        case pr_other :
          Mp->othercomp = 1;
          Mp->otheraver = 1;
          break;
        default:
          break;
      }
    }
  }
  return 0;
}



/** This function prints data to the file given by the pointer out.
   
    @param  in - pointer to the opened text file where the data will be read from

    @retval 0 - on success
*/
long outdiagm::print(FILE *out)
{
  long i;
  fprintf(out, "%ld %ld ", npun, pstep);

  for (i=0; i<npun; i++)
  {
    fprintf(out, "%d ", int(nif[i]));
    switch (nif[i])
    {
      case atnode:
        fprintf (out, "%ld ", pid[i]+1);
        break;
      case atip:
        fprintf (out, "%ld %ld ", eid[i]+1, ipeid[i]+1);
        break;
      case atxyz:
        fprintf (out, "%e %e %e ", x, y, z);
        break;
      default:
        fprintf(stderr, "\n\nUnknown type of point is required in function outdiagm::print\n");
        fprintf(stderr, " (file %s, line %d)\n", __FILE__, __LINE__); 
        return 1;
    }
    fprintf (out, "%d", int(pu[i]));

    if ((pu[i] == pr_stepid) || (pu[i] == pr_appload))
    {
      fprintf (out, "\n");
      continue;
    }
    fprintf (out, " %ld\n", ipu[i]+1);
  }

  return 0;
}



/**
  Function prints header for diagram file

  @param out - pointer to opened output text file

  @retval 0 - on success
  @retval 1 - in case of unknown required value type
*/
long outdiagm::print_header(FILE *out)
{
  long i;
  for (i=0; i<npun; i++)
  {
    switch (pu[i])
    {
      case pr_displ :
        fprintf(out, "r_%ld ", ipu[i]);
        break;
      case pr_strains :
        fprintf(out, "eps_%ld ", ipu[i]);
        break;
      case pr_stresses :
        fprintf(out, "sig_%ld ", ipu[i]);
        break;
      case pr_forces :
        fprintf(out, "f_%ld ", ipu[i]);
        break;
      case pr_react :
        fprintf(out, "R_%ld ", ipu[i]);
        break;
      case pr_stepid :
        fprintf(out, "step ");
        break;
      case pr_appload :
        fprintf(out, "lambda ");
        break;
      case pr_other :
        fprintf(out, "other_%ld ", ipu[i]);
        break;
      default:
        fprintf(stderr, "\n\nUnknown type of value for diagram is required\n");
        fprintf(stderr, " in node or ip number %ld, (file %s, line %d)\n", pid[i]+1, __FILE__, __LINE__);
        return 1;
    }
  }
  fprintf(out, "\n");
  return 0;
}



/**
  This function prints one row with required values to the output file out.
  It supposes that values in the integration points and nodes are actualized and valid.

  @param out - pointer to opened output text file
  @param lcid - load case id
  @param lambda - coefficient of applied load
  @param istep - index of current step
  @param fi - pointer to array load vector


  @retval 0 - on success
  @retval 1 - in case of wrong ip identification
  @retval 2 - in case of unknown required value type
*/
long outdiagm::printval(FILE *out, long lcid, double lambda, long istep, double *fi)
{
  long i;

  // check if we should print at given step
  if (istep % pstep)
    return 0;

  for (i=0; i<npun; i++)
  {
    if ((pid[i] < 0) && (nif[i] == atip))
    {
      if ((eid[i] < Mt->ne) && (ipeid[i] >= 0) && (ipeid[i] < Mt->give_tnip(eid[i])))
        pid[i] = Mt->elements[eid[i]].ipp[0][0]+ipeid[i];
      else
      {
        fprintf(stderr, "\n\nInvalid element number or element ip number is required in function outdiagm::print_val\n");
        fprintf(stderr, " element %ld, ip %ld (file %s, line %d)\n", eid[i]+1, ipeid[i]+1, __FILE__, __LINE__); 
        return 1;
      }
    }
    switch (pu[i])