input.cpp

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

        if (ndofn == 0) // cannot find property with description of ndof
          return(3);
        tic = new inicon; // allocating temporary initial condition class
        if ((ret = tic->read_prop(in, ndofn, Nlc))) // reading initial condition
          return(9);
        Inic[i] = tic;  // storing pointer to the nodal ic
        break;
      }
      case comcodnum :  // reading common code numbers
      {
        fprintf(stdout, "\n reading common code numbers");
        if (Nccn[i] == NULL)
        {
          for (j = 0, ndofn = 0; j < i; j++)
          // searching read properties whether given nodal property has assigned ndof
          {
            if ((Nnp[j] == Nnp[i]) && (Ndofn[j] > 0))
            {
              ndofn = Ndofn[j];
              break;
            }
          }
          if (ndofn == 0) // cannot find property with description of ndof
            return(3);
          Nccn[i] = new long[ndofn];
          memset(Nccn[i], 0, sizeof(*Nccn[i])*ndofn);
          if (getlong(in, ndir))
            return(10);
          for (j = 0; j < ndir; j++)
          {
            if (getlong(in, dir))
              return(10);
            if ((dir < 1) || (dir > ndofn))
              return(10);
            ccn++;
            Nccn[i][j] = ccn;
          }
        }
        else
          return (10);
        break;
      }
      case nodetemp :  // reading nodal temperature
      {
        fprintf(stdout, "\n reading nodal temperature");
        Ntempl = 1;
        ttln = new tempload;
        if (ttln->read(in, Nlc))
          return (11);
        Ntemp[i] = ttln;
        break;
      }
      case nodtimefunc :  // reading nodal dof time functions for growing structure problem
      {
        fprintf(stdout, "\n reading nodal dof time function");
        if (Nccn[i] == NULL)
        {
          for (j = 0, ndofn = 0; j < i; j++)
          // searching read properties whether given nodal property has assigned ndof
          {
            if ((Nnp[j] == Nnp[i]) && (Ndofn[j] > 0))
            {
              ndofn = Ndofn[j];
              break;
            }
          }
          if (ndofn == 0) // cannot find property with description of ndof
            return(3);
          Nccn[i] = new long[ndofn];
          memset(Nccn[i], 0, sizeof(*Nccn[i])*ndofn);
          for (j = 0; j < ndofn; j++)
          {
            if (getlong(in, dir))
              return(12);
            if (dir < 1)
              return(13);
            Nccn[i][j] = dir;
          }
        }
        else
          return (12);
        break;
      }
      default :
        return(1);
    }
  }
  getgkwid(xin, 1, numl); // searchs end
  nl += numl;

  getgkwid(xin,0,numl); // searchs begin
  nl += numl;
  nprop = getnprop(xin, numl);
  nl += numl;
  if (nprop < 0) // reading number of lines with element propreties
    return(32);
  nprope = nprop;
  Nep = new long[nprop]; // Array with element property numbers
  for (i = 0; i < nprop; Nep[i] = -1, i++); // setting each property number to -1
  Lel = new loadel*[nprop];  // Array with pointers to element load
  memset(Lel, 0, sizeof(*Lel)*nprop); // setting each pointer to NULL
/*  Dlel = new dloadel*[nprop];  // Array with pointers to element load
  memset(Dlel, 0, sizeof(*Dlel)*nprop); // setting each pointer to NULL*/
  Tel = new elemtype[nprop];  // Array with element types
  memset(Tel, 0, sizeof(*Tel)*nprop);  // setting each type to zero
  Ssse = new strastrestate[nprop];  // Array with stress, strain state of element
  memset(Ssse, 0, sizeof(*Ssse)*nprop);  // setting each type to zero
  Sel = new long[nprop];  // Array with element shape numbers
  memset(Sel, 0, sizeof(*Sel)*nprop);  // setting each type to zero
  Nmel = new long[nprop];  // Array with number of given material types on the element
  memset(Nmel, 0, sizeof(*Nmel)*nprop);  // setting each number of material to zero
  Mel = new mattype*[nprop];  // Array with material type numbers
  memset(Mel, 0, sizeof(*Mel)*nprop);  // setting each type number to zero
  Melid = new long*[nprop];  // Array with material type indeces
  memset(Tel, 0, sizeof(*Tel)*nprop);  // setting each material index to zero
  Ecs = new crsectype[nprop];  // Array with cross-section type numbers
  memset(Ecs, 0, sizeof(*Ecs)*nprop);  // setting each cs type number to zero
  Ecsi = new long[nprop];      // Array with cross-section type indeces
  memset(Ecsi, 0, sizeof(*Ecsi)*nprop);  // setting each cs index to zero
  Elsv = new vector*[nprop];            // Array with pointers to the
                                        //  local coordinate system base vectors arrays
  memset(Elsv, 0, sizeof(*Elsv)*nprop); //   setting each pointer lcs base vector array to NULL
  Edgl = new edgeload*[nprop];
  memset(Edgl, 0, sizeof(*Edgl)*nprop);
  Surfl = new surfload*[nprop];
  memset(Surfl, 0, sizeof(*Surfl)*nprop);
  Elsurfl = new elsurfload*[nprop];
  memset(Elsurfl, 0, sizeof(*Elsurfl)*nprop);
  Eep = new elemposition[nprop];
  for (i = 0; i < nprop; Eep[i] = elemposition(-1), i++);
  Eps = new pointset*[nprop];
  memset(Eps, 0, sizeof(*Eps)*nprop);
  Tfel = new long[nprop];
  memset(Tfel, 0, sizeof(*Tfel)*nprop);

  Nels = 0;
  // reading element properties
  fprintf(stdout, "\nReading element properties (number of entries : %ld) . . .", nprop);
  for (i = 0; i < nprop; i++)
  {
    if (getlong(in, Nep[i])) // reading property number and type
      return(21);
    tp = proptype(getpkw(in)+1);
    switch(tp)
    {
      case eltype :  // reading element type
      {
        fprintf(stdout, "\n reading element type");
        getlong(in, Sel[i]); // reading element shape number
        getint(in, (int &)Tel[i]); // reading element type number
        if (Tel[i] < 0)
          return(22);
        if ((Tel[i] >= planeelementlt) && (Tel[i] <= planeelementsubqt))
          getint(in, (int &)Ssse[i]); // reading stress strain state
        break;
      }
      case matel :  // reading element material
      {
        fprintf(stdout, "\n reading material");
        getlong(in, Nmel[i]); // reading number of given material types
        if (Nmel[i] == 0)
          return(23);
        Mel[i]   = new mattype[Nmel[i]]; // Allocating material type array
        memset(Mel[i], 0, sizeof(*Mel[i])*Nmel[i]); // setting each type to zero
        Melid[i] = new long [Nmel[i]];   // Allocating material type index array
        memset(Melid[i], 0, sizeof(*Melid[i])*Nmel[i]); // setting each index to zero
        for (j = 0; j < Nmel[i]; j++)
        {
          // reading each material type number and index number
          getint(in, (int &)Mel[i][j]);
          getlong(in, Melid[i][j]);
          if ((Mel[i][j] == 0) || (Melid[i][j] == 0))
            return(23);
        }
        break;
      }
      case crosssec :  // reading element cross-section
      {
        fprintf(stdout, "\n reading cross-section");
        // reading cs type number and cs index number
        getint(in, (int &)Ecs[i]);
        getlong(in, Ecsi[i]);
        if ((Ecs[i] == 0) || (Ecsi[i] == 0))
          return(24);
        break;
      }
      case loadelems :  // reading element load
      {
        fprintf(stdout, "\n reading element load");
        tle = new loadel;  // allocating temporary lodel class
        nne = -1;
        for (j = 0; j < Top->elements; j++)
        // searching for the first element with desired property number
        // to determine number of nodes on the element
        {
          if (Top->E[j].property == Nep[i])
          {
            nne = Top->E[j].size;
            break;
          }
        }
        if (nne < 0)
	{
          delete tle;
          getnextln(in);
	  break;
        }
	//nne = Top->E[0].size;
	//	nne=8;
        if ((ret = tle->read_prop(in, nne, Nlc))) // reading element load
          return(25);
        Lel[i] = tle;  // storing element load
        break;
      }
/*    NOT IMPLEMENTED YET
      case dloadelems : //reading dynamic element load
      {
        tdle = new dloadel;  // allocating temporary lodel class
        for (j = 0; j < Top->elements; j++)
        // searching for the first element with desired property number
        // to determine number of nodes on the element
        {
          if (Top->E[j].property == Nep[i])
          {
            nne = Top->E[j].size;
            break;
          }
        }
        if ((ret = tdle->read_prop(in, nne, Nlc))) // reading element load
          return(26);
        Dlel[i] = tdle;  // storing dynamic element load
        break;
      }*/
      case localsystem :  // reading local coordinate system for integartion points
      {
        fprintf(stdout, "\n reading element lcs");
        getlong(in, nv);  // reading number of lcs base vectors
        tlsv = new vector[nv];  // allocating temporary array of lcs base vectors
        for (j = 0; j < nv; j++)
        {
          allocv(nv, tlsv[j]);
          if (readv(in, tlsv[j]))  // reading the first base vector
             return(27);
        }
        Nels++;
        Elsv[i] = tlsv;          // storing pointer to the array of lcs base vectors
        break;
/*        switch (Mp->nstrcomp)
        {
          case 2 :
            tlsv = new vector[nv](2);  // allocating temporary array of lcs base vectors
            if (readv(in, tlsv[0]))  // reading the first base vector
              return(27);
            if (readv(in, tlsv[1]))  // reading the second base vector
              return(27);
            Nels++;
            Elsv[i] = tlsv;          // storing pointer to the array of lcs base vectors
            break;
          case 4 :
            tlsv = new vector[nv](3);
            if (readv(in, tlsv[0]))  // reading the first base vector
              return(27);
            if (readv(in, tlsv[1]))  // reading the second base vector
              return(27);
            if (readv(in, tlsv[2]))  // reading the third base vector
              return(27);
            Nels++;
            Elsv[i] = tlsv;          // storing pointer to the array of lcs base vectors
            break;
          case 6 :
            tlsv = new vector[nv](3);
            if (readv(in, tlsv[0]))  // reading the first base vector
              return(27);
            if (readv(in, tlsv[1]))  // reading the second base vector
              return(27);
            if (readv(in, tlsv[2]))  // reading the third base vector
              return(27);
            Nels++;
            Elsv[i] = tlsv;          // storing pointer to the array of lcs base vectors
            break;
          default :
            return(27);
        }  // end of case number of lcs base vectors
        break;*/
      }  // end of main case
      case loadedge :
      {
        fprintf(stdout, "\n reading element edge load");
        Edgl[i] = new edgeload;
        if(Edgl[i]->read(in, Nlc))
          return (28);
        break;
      }
      case surfaceload :
      {
        fprintf(stdout, "\n reading surface load");
        Surfl[i] = new surfload;
        if(Surfl[i]->read(in, Nlc))
          return (29);
        break;
      }
      case elsurfaceload :
      {
        fprintf(stdout, "\n reading element surface load");
        Elsurfl[i] = new elsurfload;
        if(Elsurfl[i]->read(in, Nlc))
          return (30);
        break;
      }
      case eltimefunc :  // reading element time function
      {
        fprintf(stdout, "\n reading element time function");
        getlong(in, Tfel[i]); // reading element shape number
        break;
      }
/*      case sscomp :
      {
        fprintf(stdout, "\n reading stres/strain comp. info");
        if (getlong(in, Sel[i]))
          return (30);
        if (getint(in, int(Eep[i])))
          return (30);
        switch(Eep[i])
        {
          case nowhere : break;
          case intpts  : break;
          case enodes  : break;
          case userdefined :
            Eps[i] = new pointset;
            if (Eps[i]->read(in))
              return (30);
            break;
          default :
            return(30);
        }
        break;
      }*/
      default :
        return(21);
    }
  }
//  Mp->nlcsip = Nels;
  getgkwid(xin, 1,numl); // searchs end
  nl += numl;
  return(0);
}