param.c

OpenFVM-v1.1 open source cfd code

		  if (parameter.adjdt == LOGICAL_TRUE)
		    PetscPrintf (PETSC_COMM_WORLD,
				 "Adjust time intervals.\n");
		  else
		    PetscPrintf (PETSC_COMM_WORLD,
				 "Do not adjust time intervals.\n");
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30201:

		  // Maximum Courant number
		  GetLine (fp);
		  fscanf (fp, "%f", &parameter.maxCp);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Maximum Courant number: \t\t\t%.3f\n",
			       parameter.maxCp);
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30400:

		  // Number of saves
		  GetLine (fp);
		  fscanf (fp, "%d", &parameter.nsav);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Number of saves: \t\t\t\t%d\n",
			       parameter.nsav);
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30440:

		  // Save face flux
		  GetLine (fp);
		  fscanf (fp, "%d", &parameter.savflux);

		  PetscPrintf (PETSC_COMM_WORLD, "Save flux: \t\t\t\t\t%d\n",
			       parameter.savflux);
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30450:

		  // Write face scalars (u v w p T s)
		  GetLine (fp);
		  for (j = 0; j < nphi; j++)
		    fscanf (fp, "%d", &parameter.fsav[j]);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Variable: \t\t\t\t\t[ u v w p T s]\n");
		  PetscPrintf (PETSC_COMM_WORLD,
			       "Save scalars on face: \t\t\t\t[");
		  for (j = 0; j < nphi; j++)
		    PetscPrintf (PETSC_COMM_WORLD, " %d", parameter.fsav[j]);
		  PetscPrintf (PETSC_COMM_WORLD, "]\n");
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30455:

		  //Write face vectors (uvw)
		  GetLine (fp);
		  fscanf (fp, "%d", &parameter.fvec);

		  if (parameter.fvec == LOGICAL_TRUE)
		    PetscPrintf (PETSC_COMM_WORLD,
				 "Save face - vector magnitude: \t\t\t[yes]\n");
		  else
		    PetscPrintf (PETSC_COMM_WORLD,
				 "Save face - vector magnitude: \t\t\t[no]\n");
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30460:

		  // Write element scalars (u v w p T s)
		  GetLine (fp);
		  for (j = 0; j < nphi; j++)
		    fscanf (fp, "%d", &parameter.csav[j]);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Variable: \t\t\t\t\t[ u v w p T s]\n");
		  PetscPrintf (PETSC_COMM_WORLD,
			       "Save scalars in cell: \t\t\t\t[");
		  for (j = 0; j < nphi; j++)
		    PetscPrintf (PETSC_COMM_WORLD, " %d", parameter.csav[j]);
		  PetscPrintf (PETSC_COMM_WORLD, "]\n");
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30465:

		  // Write element vectors (uvw)
		  GetLine (fp);
		  fscanf (fp, "%d", &parameter.cvec);

		  if (parameter.cvec == LOGICAL_TRUE)
		    PetscPrintf (PETSC_COMM_WORLD,
				 "Save cell center - vector: \t\t\t[yes]\n");
		  else
		    PetscPrintf (PETSC_COMM_WORLD,
				 "Save cell center - vector: \t\t\t[no]\n");
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30470:

		  // Write vorticity (x y z)
		  GetLine (fp);
		  for (j = 0; j < 3; j++)
		    fscanf (fp, "%d", &parameter.vortex[j]);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Axis: \t\t\t\t\t\t[ x y z]\n");
		  PetscPrintf (PETSC_COMM_WORLD, "Save vorticity: \t\t\t\t[");
		  for (j = 0; j < 3; j++)
		    PetscPrintf (PETSC_COMM_WORLD, " %d",
				 parameter.vortex[j]);
		  PetscPrintf (PETSC_COMM_WORLD, "]\n");
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30475:

		  // Write stream function (xy)
		  GetLine (fp);
		  fscanf (fp, "%d", &parameter.streamf);

		  if (parameter.streamf == LOGICAL_TRUE)
		    PetscPrintf (PETSC_COMM_WORLD,
				 "Save stream function in xy plane\n");
		  else
		    PetscPrintf (PETSC_COMM_WORLD,
				 "Do not save stream function in xy plane\n");
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30485:

		  // Probe (u v w p T s)
		  GetLine (fp);
		  for (j = 0; j < nphi; j++)
		    fscanf (fp, "%d", &parameter.probe[j]);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Variable: \t\t\t\t\t[ u v w p T s]\n");
		  PetscPrintf (PETSC_COMM_WORLD,
			       "Probe options: \t\t\t\t\t[");
		  for (j = 0; j < nphi; j++)
		    PetscPrintf (PETSC_COMM_WORLD, " %d", parameter.probe[j]);
		  PetscPrintf (PETSC_COMM_WORLD, "]\n");
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30500:

		  // Smooth
		  GetLine (fp);
		  fscanf (fp, "%d", &parameter.smooth);

		  if (parameter.smooth == LOGICAL_TRUE)
		    PetscPrintf (PETSC_COMM_WORLD,
				 "Smooth probe values: \t\t\t\t[yes]\n");
		  else
		    PetscPrintf (PETSC_COMM_WORLD,
				 "Smooth probe values: \t\t\t\t[no]\n");
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30550:

		  // Maximum number of non-othorgonal corrections
		  GetLine (fp);
		  fscanf (fp, "%d", &parameter.northocor);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Maximum number of non-orthogonal corrections: \t%d\n",
			       parameter.northocor);
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30551:

		  // Orthogonal factor
		  GetLine (fp);
		  fscanf (fp, "%f", &parameter.orthof);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Orthogonal factor: \t\t\t\t%E\n",
			       parameter.orthof);
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30600:

		  // Convergence criterion (matrix solution) 
		  GetLine (fp);
		  for (j = 0; j < nphi; j++)
		    fscanf (fp, "%f", &parameter.mtol[j]);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Variable: \t\t\t\t\t[ u v w p T s]\n");
		  PetscPrintf (PETSC_COMM_WORLD,
			       "Matrix solution tolerance: \t\t\t[");
		  for (j = 0; j < nphi; j++)
		    PetscPrintf (PETSC_COMM_WORLD, " %+.3E",
				 parameter.mtol[j]);
		  PetscPrintf (PETSC_COMM_WORLD, "]\n");
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30601:

		  // Maximum number of iterations (matrix solution)
		  GetLine (fp);
		  for (j = 0; j < nphi; j++)
		    fscanf (fp, "%d", &parameter.miter[j]);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Variable: \t\t\t\t\t[ u v w p T s]\n");
		  PetscPrintf (PETSC_COMM_WORLD,
			       "Matrix solution iterations: \t\t\t[");
		  for (j = 0; j < nphi; j++)
		    PetscPrintf (PETSC_COMM_WORLD, " %d", parameter.miter[j]);
		  PetscPrintf (PETSC_COMM_WORLD, "]\n");
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30650:

		  // Matrix solver (u v w p T s) (0-NONE, 1-JACOBI, 2-SOR, 3-QMR, 4-GMRES, 5-CG, 6-CGN, 7-CGS, 8-BICG, 9-BICGS)

		  GetLine (fp);
		  for (j = 0; j < nphi; j++)
		    fscanf (fp, "%d", &parameter.msolver[j]);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Variable: \t\t\t\t\t[ u v w p T s]\n");
		  PetscPrintf (PETSC_COMM_WORLD, "Solver: c) \t\t\t\t\t[");
		  for (j = 0; j < nphi; j++)
		    PetscPrintf (PETSC_COMM_WORLD, " %d",
				 parameter.msolver[j]);
		  PetscPrintf (PETSC_COMM_WORLD, "]\n");
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30651:

		  // Matrix preconditioner (0-NONE, 1-JACOBI, 2-SOR, 3-ILU)
		  GetLine (fp);
		  for (j = 0; j < nphi; j++)
		    fscanf (fp, "%d", &parameter.mprecond[j]);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Variable: \t\t\t\t\t[ u v w p T s]\n");
		  PetscPrintf (PETSC_COMM_WORLD,
			       "Pre-conditioner: d) \t\t\t\t[");
		  for (j = 0; j < nphi; j++)
		    PetscPrintf (PETSC_COMM_WORLD, " %d",
				 parameter.mprecond[j]);
		  PetscPrintf (PETSC_COMM_WORLD, "]\n");
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30800:

		  // Interface scheme factor - CICSAM
		  GetLine (fp);
		  fscanf (fp, "%f", &parameter.kq);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Interface scheme factor: \t\t\t%.3f\n",
			       parameter.kq);
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 30900:

		  // Maximum number of CICSAM corrections

		  GetLine (fp);
		  fscanf (fp, "%d", &parameter.ncicsamcor);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Number of CICSAM corrections: \t\t\t%d\n",
			       parameter.ncicsamcor);
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 32000:

		  // Start time
		  GetLine (fp);
		  fscanf (fp, "%f", &parameter.t0);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Start time: \t\t\t\t\t%+.3E s\n",
			       parameter.t0);
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 32001:

		  // End time
		  GetLine (fp);
		  fscanf (fp, "%f", &parameter.t1);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "End time: \t\t\t\t\t%+.3E s\n", parameter.t1);
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 32002:

		  // Time interval
		  GetLine (fp);
		  fscanf (fp, "%f", &parameter.dt);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Time interval: \t\t\t\t\t%+.3E s\n",
			       parameter.dt);
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 33050:

		  // Simulate filling
		  GetLine (fp);
		  fscanf (fp, "%d", &parameter.fill);

		  if (parameter.fill == LOGICAL_TRUE)
		    PetscPrintf (PETSC_COMM_WORLD,
				 "Simulate filling: \t\t\t\t[yes]\n");
		  else
		    PetscPrintf (PETSC_COMM_WORLD,
				 "Simulate filling: \t\t\t\t[no]\n");
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 33051:

		  // Completely filled percentage
		  GetLine (fp);
		  fscanf (fp, "%f", &parameter.pf);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Stop filling at: \t\t\t\t%.2f%%\n",
			       parameter.pf);
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		case 34000:

		  // Gravity vector
		  GetLine (fp);
		  fscanf (fp, "%f %f %f", &parameter.g[0], &parameter.g[1],
			  &parameter.g[2]);

		  PetscPrintf (PETSC_COMM_WORLD,
			       "Gravity vector (x): \t\t\t\t%+.3E m/s^2\n",
			       parameter.g[0]);
		  PetscPrintf (PETSC_COMM_WORLD,
			       "Gravity vector (y): \t\t\t\t%+.3E m/s^2\n",
			       parameter.g[1]);
		  PetscPrintf (PETSC_COMM_WORLD,
			       "Gravity vector (z): \t\t\t\t%+.3E m/s^2\n",
			       parameter.g[2]);
		  PetscPrintf (PETSC_COMM_WORLD, "\n");

		  break;

		default:

		  PetscPrintf (PETSC_COMM_WORLD,
			       "\nError: Unknown parameter code (%d).\n",
			       tcode);
		  exit (LOGICAL_ERROR);
		  break;

		}

	    }

	}

    }
  while (!feof (fp));

  fclose (fp);

  PetscPrintf (PETSC_COMM_WORLD, "a) Interpolation scheme list\n");
  PetscPrintf (PETSC_COMM_WORLD, "%d-UDS\n", UDS);
  PetscPrintf (PETSC_COMM_WORLD, "%d-CDS\n", CDS);
  PetscPrintf (PETSC_COMM_WORLD, "\n");
  PetscPrintf (PETSC_COMM_WORLD, "b) Time advancement method list\n");
  PetscPrintf (PETSC_COMM_WORLD, "%d-Explicit\n", EXPLICITEULER);
  PetscPrintf (PETSC_COMM_WORLD, "%d-Implicit\n", IMPLICITEULER);
  PetscPrintf (PETSC_COMM_WORLD, "%d-Crank Nicolson\n", CRANKNICOLSON);
  PetscPrintf (PETSC_COMM_WORLD, "\n");
  PetscPrintf (PETSC_COMM_WORLD, "c) Solvers list\n");
  //PetscPrintf (PETSC_COMM_WORLD, "%d-Jacobi\n", sJACOBI);
  //PetscPrintf (PETSC_COMM_WORLD, "%d-SOR\n", sSOR);
  //PetscPrintf (PETSC_COMM_WORLD, "%d-QMR\n", sQMR);
  PetscPrintf (PETSC_COMM_WORLD, "%d-GMRES\n", sGMRES);
  PetscPrintf (PETSC_COMM_WORLD, "%d-CR\n", sCR);
  PetscPrintf (PETSC_COMM_WORLD, "%d-CG\n", sCG);
  PetscPrintf (PETSC_COMM_WORLD, "%d-CGS\n", sCGS);
  PetscPrintf (PETSC_COMM_WORLD, "%d-BiCG\n", sBICG);
  PetscPrintf (PETSC_COMM_WORLD, "%d-BiCGStab\n", sBICGS);
  PetscPrintf (PETSC_COMM_WORLD, "\n");
  PetscPrintf (PETSC_COMM_WORLD, "d) Pre-conditioners list\n");
  PetscPrintf (PETSC_COMM_WORLD, "%d-None\n", pNONE);
  PetscPrintf (PETSC_COMM_WORLD, "%d-Jacobi\n", pJACOBI);
  PetscPrintf (PETSC_COMM_WORLD, "%d-SOR\n", pSOR);
  PetscPrintf (PETSC_COMM_WORLD, "%d-ILU\n", pILU);
  PetscPrintf (PETSC_COMM_WORLD, "%d-ASM\n", pASM);
  PetscPrintf (PETSC_COMM_WORLD, "\n");

  PetscPrintf (PETSC_COMM_WORLD, "Done.\n");

  return LOGICAL_TRUE;

}