probdesc.jk

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

    
    //  auxiliary data output
    fscanf (in,"%ld",&adp);
    if (adp==1){
      ado = new auxdatout;
      ado->read (in);
    }
    
    break;
  }
  case mech_timedependent_prob:{
    if (Mespr==1)  fprintf (stdout,"\n system of nonlinear equations will be solved by visco-solver");

    //  auxiliary output file
    getnextln(in);
    inputln (in,auxfile,1000);

    //  number of iterations, time increment
    fscanf (in,"%ld %lf",&nivs,&incrvs);
    fscanf (in,"%d %d",(int*)&tlinsol,(int*)&tstorsm);

    //  number of printed unknowns in non-linear solvers
    fscanf (in,"%ld",&npun);
    requn = new long [2*npun];
    memset (requn,0,2*npun*sizeof(long));
    //  printed unknowns in non-linear solvers
    read_prunk (in,requn,npun);
    
    //  auxiliary data output
    fscanf (in,"%ld",&adp);
    if (adp==1){
      ado = new auxdatout;
      ado->read (in);
    }
    break;
  }
  case earth_pressure:
  {
    if (Mespr==1)
      fprintf (stdout,"\n system of nonlinear equations will be solved by earth pressure solver");
    fscanf (in,"%d %d",(int*)&tlinsol,(int*)&tstorsm);
    fscanf (in,"%d %ld %ld %lf",(int*)&tepsol,&niep,&niiep,&errep);
    break;
  }
  default:{
    fprintf (stderr,"\n\n unknown problem type is required in function probdesc::read (%s, line %d).\n",__FILE__,__LINE__);
  }
  }
  
}

/**
   function prints data for pre-processor

   @param out - output stream
*/
void probdesc::print (FILE *out)
{
  long i;

  //  problem name
  fprintf (out, "%s\n", name);

  //  output file
  fprintf (out, "%s\n", outfile);

  //  detail messages
  fprintf (out, "%ld\n", Mespr);

  //  problem type
  fprintf (out, "%d\n", (int)tprob);
  
  //  computation of strains, stresses and reactions
  fprintf (out,"%ld ",straincomp);
  if (straincomp==1)  fprintf (out,"%ld ",strainaver);
  
  fprintf (out,"%ld ",stresscomp);
  if (stresscomp==1)  fprintf (out,"%ld ",stressaver);
  
  fprintf (out,"%ld\n",reactcomp);
  
  //  presence of adaptivity
  fprintf (out,"%ld ",adaptivity);
  if (adaptivity>0)
    fprintf (out," %ld %f",diagonalization,adapt_accuracy);

  fprintf (out,"\n\n");

  
  switch (tprob){
  case linear_statics:{
    
    //  tstorsm - type of storage of stiffness matrix
    //  tlinsol - type of solver of linear equation system
    fprintf (out, "%d %d\n", (int)tstorsm, (int)tlinsol);
    switch (tlinsol){
    case cg:{
      fprintf (out,"%ld %e", nicg, errcg);
      fprintf (out, "  %d", (int)tprec);
      break;
    }
    case bicg:{
      fprintf (out,"%ld %f",nicg,errcg);
      break;
    }
    default :
      break;
    }
    
    switch (tprec){
    case ssorprec:{
      fprintf (out, " %f", ssoromega);
      break;
    }
    case incomdec:{
      fprintf (out, " %f", indegamma);
      break;
    }
    default:
      break;
    }
    
    fprintf(out, "\n");
    break;
  }
    
  case eigen_dynamics:{
    fprintf (out, "%d %d %d\n", (int)teigsol, (int)tstorsm, (int)tstormm);
    switch (teigsol)
      {
      case inv_iteration:
        {
          fprintf (out, "%ld %e", nies, erres);
          break;
        }
      case subspace_it_jacobi:
        {
          fprintf (out, "%ld %ld %ld %e", neigv, nev, nies, erres);
          fprintf (out," %ld %ld\n",nijmr,njacthr);
          for (i=0;i<njacthr;i++){
            fprintf (out," %e",jacthr[i]);
          }
          break;
        }
      case subspace_it_gsortho:
        {
          fprintf (out, "%ld %ld %ld %e", neigv, nev, nies, erres);
          break;
        }
      default:
        break;
      }
    
    fprintf (out,"\n");
    
    break;
  }
  case forced_dynamics:
    {
      //  auxiliary output file
      fprintf (out, "%s\n", auxfile);
      
      fprintf (out,"%d %d %d\n",(int)tforvib,(int)tstorsm,(int)tstormm);
      switch (tforvib){
      case newmark:{
        fprintf (out, "%ld %f %f %f", nifv, timeincr, alphafvn, deltafvn);
        break;
      }
      case hughes:{
        fprintf (out, "%ld %f %f %f", nifv, timeincr, betafvh, gammafvh);
        break;
      }
      default:{
        fprintf (stderr,"\n\n unknown solver of forced vibration is required");
        fprintf (stderr,"\n in function probdesc::print (%s, line %d).\n",__FILE__,__LINE__);
      }
      }
      fprintf (out,"\n %ld",npun);
      //  printed unknowns in forced dynamics
      print_prunk (out,requn,npun);
      
      //  auxiliary data output
      fprintf (out,"%ld",adp);
      if (adp==1){
        ado->printin (out);
      }
      
      break;
    }
  case nonlinear_statics:
    {
      //  auxiliary output file
      fprintf (out, "%s\n", auxfile);

      //  type of non-linear solver, type of stress retrun algorithm
      fprintf (out, "%d %d\n", (int)tnlinsol, (int)tsra);
      fprintf (out, "%d %d\n", (int)tlinsol, (int)tstorsm);
      
      switch (tnlinsol)
        {
        case arcl:
          {
            fprintf (out, "%ld %ld %e %e %e %e %e\n", nial, niilal, erral, dlal,
                     dlminal, dlmaxal, psial);
          
          fprintf (out,"%ld %d\n",hdbackupal,displnorm);

          switch (displnorm){
          case alldofs:{  break; }
          case seldofs:{
            fprintf (out,"%ld\n",nsdofal);
            print_seldof (out,selnodal,seldofal,nsdofal);
            break;
          }
          case selnodes:{
            fprintf (out,"%ld\n",nsnal);
            print_selnod (out,selnodal,nsnal);
            break;
          }
          case nodesdistincr:{
            nsnal=2;
            fprintf (out,"%ld\n",probdimal);
            print_selnod (out,selnodal,nsnal);
            break;
          }
          default:{
            fprintf (stderr,"\n\n unknown norm measurement of displacement increment \n");
          }
          }
          
          break;
        }
        case newton:
        {
          fprintf (out, "%ld %ld %e %e %e\n", ninr, niilnr, errnr, incrnr, minincrnr);
          break;
        }
        case visco_sol:
        {
          fprintf (out, "%ld %e\n", nivs, incrvs);
          break;
        }
      }

      switch (tsra)
      {
        case cp:
        {
          fprintf (out, "%ld %e\n", nicp, errcp);
          break;
        }
        case cppvp:
        {
          fprintf (out, "%ld %e %e\n", nicppvp, errcppvp, ddtcppvp);
          break;
        }
      }

      //  number of printed unknowns in non-linear solvers
      fprintf (out, "%ld\n", npun);
      //  printed unknowns in non-linear solvers
      print_prunk (out,requn,npun);

      //  auxiliary data output
      fprintf (out,"%ld",adp);
      if (adp==1){
        ado->printin (out);
      }

      break;
    }
    case mech_timedependent_prob:
    {
      //  auxiliary output file
      fprintf (out, "%s\n", auxfile);
      
      //  number of iterations, time increment
      fprintf (out,"%ld %e\n", nivs, incrvs);
      fprintf (out,"%d %d\n",(int)tlinsol,(int)tstorsm);


      //  number of printed unknowns in non-linear solvers
      fprintf (out,"%ld\n", npun);
      //  printed unknowns in non-linear solvers
      print_prunk (out,requn,npun);
    
      //  auxiliary data output
      fprintf (out,"%ld",adp);
      if (adp==1){
        ado->printin (out);
      }

      break;
    }
    default :
      break;
  }
  fprintf (out,"\n");
}





void probdesc::read_prunk (FILE *in,long *requn,long npun)
{
  long i;
  for (i=0;i<npun;i++){
    fscanf (in,"%ld %ld",requn+2*i+0,requn+2*i+1);
    requn[2*i+0]-=1;  requn[2*i+1]-=1;
  }
}

void probdesc::print_prunk (FILE *out,long *requn,long npun)
{
  long i;
  for (i=0;i<npun;i++)
    fprintf (out, "%ld %ld\n", requn[2*i+0]+1, requn[2*i+1]+1);
}

void probdesc::read_selnod (FILE *in,long *selnodal,long nsnal)
{
  long i;
  
  for (i=0;i<nsnal;i++){
    fscanf (in,"%ld",selnodal+i);
    selnodal[i]--;
  }
  
}

void probdesc::read_seldof (FILE *in,long *selnodal,long *seldofal,long nsdofal)
{
  long i;
  
  for (i=0;i<nsdofal;i++){
    fscanf (in,"%ld %ld",selnodal+i,seldofal+i);
    selnodal[i]--;  seldofal[i]--;
  }
  
}

void probdesc::print_selnod (FILE *out,long *selnod,long nsnal)
{
  long i;
  
  for (i=0;i<nsnal;i++){
    fprintf (out,"%ld\n",selnod[i]+1);
  }
  
}

void probdesc::print_seldof (FILE *out,long *selnodal,long *seldofal,long nsdofal)
{
  long i;
  
  for (i=0;i<nsdofal;i++){
    fprintf (out,"%ld %ld\n",selnodal[i]+1,seldofal[i]+1);
  }
  
}

void probdesc::provizorium (gmatrix *gm)
{
  gm->tlinsol=tlinsol;
  gm->tprec=tprec;
  
  gm->nicg=nicg;
  gm->errcg=errcg;
  gm->omega=ssoromega;
  gm->indegamma=indegamma;
  gm->limit=limit;
  gm->zero=zero;
}