Exemplo n.º 1
0
int
main (int argc, char **argv)
{
  /* Allocate a 2d array */
  ofstream fout;
  ofstream gout;
  ofstream fin;
  ofstream logfile;
  ifstream init;


  int inject_jet=0;


  int ii = 0, jj = 0, kk = 0, hh = 0;
  int rc;
  int timestep = 0;
  int maxstep = 0;
  int printtime = 10;
  int second = 0;
  double max_speed = 0.0;
  double maxtime = 0.0;
  double *maximumspeed = &max_speed;
  double time = 0.0;
  double delta_t = 0.0;
  double dtodx = 0.0;
  double del = 0.0;
  double delh = 0.0;
  double cfl = 0.80;
  double gammam1 = gammag - 1;
  double fn[8];
  zone maxvar;
  zone minvar;
#ifdef DEBUG
  double px, py, et, ri, rl, ul, vl, ke, pl, al;
#endif /* DEBUG */

  clock_t start, end;
  double elapsed;
  double den_temp[4];
  string probtype;


  start = clock ();


  gammag = 5.0 / 3.0;
//  gammag =1.4;
//  
  /*
     init.open ("input/init.dat");
     init >> nx >> ny;
     init >> maxstep;
     init >> cfl;
     init.close ();
   */
  logfile.open ("output/roe.log");
  logfile.close ();
  logfile.open ("output/falle.log");
  logfile.close ();
  logfile.open ("logfile.txt");
  logfile.close ();
  ne = 8;


  if (argc > 1)
    {
      init.open (argv[1]);
    }
  else
    {
      init.open ("input/gaz1");
    }

  init >> nx;
  init.ignore (256, '\n');
  init >> ny;
  init.ignore (256, '\n');
  init >> maxstep;
  init.ignore (256, '\n');
  init >> cfl;
  init.ignore (256, '\n');
  init >> printtime;
  init.ignore (256, '\n');
  init >> delta_x;
  init.ignore (256, '\n');
  init >> gammag;
  init.ignore (256, '\n');
  init >> maxtime;
  init.ignore (256, '\n');
  init >> probtype;
  init.close ();


  gammam1 = gammag - 1;


  nz = 1;
  Array3D < zone > grid (nx, ny, nz);
  Array3D < zone > gridh (nx, ny, nz);
  Array3D < zone > gridn (nx, ny, nz);
  Array3D < zone > fx (nx, ny, nz);
  Array3D < zone > fy (nx, ny, nz);
  Array3D < zone > xResState (nx, ny, nz);
  Array3D < zone > yResState (nx, ny, nz);

  delta_x = 1.0 / nx;

  cout << "\t\t\t2D Roe Solver Code" << endl;
  cout << "\t\t\tVersion 2.0" << endl;
  cout << "\t\t\tNo of steps =  " << maxstep << endl;
  cout << "\t\t\tNX    =  " << nx << endl;
  cout << "\t\t\tNY    =  " << ny << endl;
  cout << "\t\t\tNE    =  " << ne << endl;
  cout << "\t\t\tCFL   =  " << cfl << endl;
  cout << "\t\t\tdel_x =  " << delta_x << endl;
  cout << "\t\t\tGamma =  " << gammag << endl;
#ifdef SECOND_ORDER_TIME
  cout << "\t\t\t2nd Order Time and Space " << endl;
#endif /* SECOND_ORDER_TIME */
#ifdef LAPIDUS_VISCOSITY
  cout << "\t\t\tLapidus Viscosity " << endl;
#endif /* LAPIDUS_VISCOSITY */
  cout << endl;
  cout << endl;

  // Set up initial values of conserved variables on the grid */


  if (probtype == "Shock")
    {
      if (argc > 1)
	{
	  rc = initialise (argv[1], grid, &maxstep, &cfl);
	}
      else
	{
	  rc = initialise ("input/gaz1", grid, &maxstep, &cfl);
	}

    }

  else if (probtype == "Jet")
    {
      if (argc > 1)
	{
	  rc = initialise_jet (argv[1], grid, &maxstep, &cfl);
	}
      else
	{
	  rc = initialise_jet ("input/input.jet", grid, &maxstep, &cfl);
	}
    }

  else if (probtype == "Blast")
    {
      if (argc > 1)
	{
	  rc = initialise_blast (argv[1], grid, &maxstep, &cfl);
	}
      else
	{
	  rc = initialise_blast ("input/input.jet", grid, &maxstep, &cfl);
	}
    }



/* Print out the initial array */
  fin.open ("infile.txt");
  for (ii = 0; ii < nx; ii++)
    {
      for (jj = 0; jj < ny; jj++)
	{
	  fin << ii
	    << " " << jj
	    << " " << grid[ii][jj][kk] _MASS
	    << " " << grid[ii][jj][kk] _MOMX
	    << " " << grid[ii][jj][kk] _MOMY
	    << " " << grid[ii][jj][kk] _MOMZ
	    << " " << grid[ii][jj][kk] _ENER
	    << " " << grid[ii][jj][kk] _B_X
	    << " " << grid[ii][jj][kk] _B_Y
	    << " " << grid[ii][jj][kk] _B_Z << endl;
	}
    }
  fin.close ();


#ifdef DEBUG1
  for (ii = 0; ii < nx; ii++)
    {
      for (jj = 0; jj < ny; jj++)
	{
	  cout << grid[ii][jj][kk] _MASS << "\t";
	}
      cout << endl;
    }

#endif
/* Using a second order in time Runge-Kutta method, advect the array */

	  rc = output (grid, fx, fy, 0, "out_2d_");
  for (timestep = 1; timestep < maxstep; timestep++)
    {
      for (int k = 0; k < ne; k++)
	{
	  maxvar.array[k] = 0.;
	  minvar.array[k] = 999.;
	}
      /* Set the maximum wave speed to zero */
      *maximumspeed = 0;
      /* Determine the maximum wave speed for use in
       * the time step */
      rc = maxspeed (grid, maximumspeed);

      /* Determine a value for time advance and courant number based on the
       * maximum wave speed */

      del = cfl / *maximumspeed;
      delh = 0.5 * del;
      delta_t = del * delta_x;
		dtodx = 1.0/ *maximumspeed;
      time = time + delta_t;
#ifdef VERBOSE_OUTPUT
      cout << "Tstep= " << setiosflags (ios::scientific) << timestep;
      cout << "\tTime= " << setiosflags (ios::scientific) << time;
      cout << "\tMaxspeed= " << setiosflags (ios::
					     scientific) << *maximumspeed;
      cout << "\t dt = " << setiosflags (ios::scientific) << delta_t;
      cout << "\tCFL= " << setiosflags (ios::scientific) << del;
      cout << endl;
#endif /* VERBOSE_OUTPUT */


//  rc = output ( grid, fx, fy, timestep, "oldg_2d_");

#ifdef SECOND_ORDER_TIME
      jj = 0;


#ifdef TWODIM
      for (jj = 2; jj < ny - 1; jj++)
#endif /* TWODIM */
	{
	  for (ii = 2; ii < nx - 1; ii++)
	    {
	      rc =
		flux (grid, fx[ii][jj][kk].array, xResState[ii][jj][kk].array, dtodx,
		      ii, jj, timestep, 1, 0);
#ifdef TWODIM
	      rc =
		flux (grid, fy[ii][jj][kk].array, yResState[ii][jj][kk].array,dtodx,
		      ii, jj, timestep, 2, 0);
#endif /* TWODIM */
	    }
	}

//#ifdef TWODIM
//          for (jj = 2; jj < ny - 2; jj++)
//#endif /* TWODIM */
//        {
      //      for (ii = 2; ii < nx - 2; ii++)
//             {

      rc =
	update (gridh, grid, fx, fy, xResState, yResState, delh, ii, jj,
		timestep, grid, delta_t, 0);

//             }
//        }

      /* Boundary Conditions */
      rc = boundary (gridh, inject_jet);
      /* End Boundary Conditions */
#ifdef DEBUG_HALFSTEP
      if (timestep % printtime == 0)
	{
	  rc = output (gridh, fx, fy, timestep, "hout_2d_");
	}
#endif /* DEBUG HALFSTEP */


#ifdef TWODIM
      for (jj = 2; jj < ny - 1; jj++)
#endif /* TWODIM */
	{
	  for (ii = 2; ii < nx - 1; ii++)
	    {
	      rc =
		flux (gridh, fx[ii][jj][kk].array,
		      xResState[ii][jj][kk].array,dtodx, ii, jj, timestep, 1, 1);
#ifdef TWODIM
	      rc =
		flux (gridh, fy[ii][jj][kk].array,
		      yResState[ii][jj][kk].array,dtodx, ii, jj, timestep, 2, 1);
#endif /* TWODIM */
	    }
	}

      rc =
	update (gridn, grid, fx, fy, xResState, yResState, del, ii, jj,
		timestep, gridh, delta_t, 1);
#ifdef TWODIM
      for (jj = 2; jj < ny - 2; jj++)
#endif /* TWODIM */
	{
	  for (ii = 2; ii < nx - 2; ii++)
	    {
	      for (int k = 0; k < ne; k++)
		{
		  maxvar.array[k] =
		    (maxvar.array[k] >
		     gridn[ii][jj][kk].array[k] ? maxvar.
		     array[k] : gridn[ii][jj][kk].array[k]);
		  minvar.array[k] =
		    (minvar.array[k] <
		     gridn[ii][jj][kk].array[k] ? minvar.
		     array[k] : gridn[ii][jj][kk].array[k]);
		}

	    }
	}
      grid = gridn.copy ();
//      rc = output ( gridh, fx, fy, timestep, "hout_2d_");
#else /* First order */


#ifdef TWODIM
      for (jj = 2; jj < ny - 1; jj++)
#endif /* TWODIM */
	{
	  for (ii = 2; ii < nx - 1; ii++)
	    {
	      rc =
		flux (grid, fx[ii][jj][kk].array, xResState[ii][jj][kk].array,dtodx,
		      ii, jj, timestep, 1, 0);
#ifdef TWODIM
	      rc =
		flux (grid, fy[ii][jj][kk].array, yResState[ii][jj][kk].array,dtodx,
		      ii, jj, timestep, 2, 0);
#endif /* TWODIM */
	    }
	}

      rc =
	update (gridn, grid, fx, fy, xResState, yResState, del, ii, jj,
		timestep, grid, delta_t, 0);
#ifdef TWODIM
      for (jj = 2; jj < ny - 2; jj++)
#endif /* TWODIM */
	{
	  for (ii = 2; ii < nx - 2; ii++)
	    {

	      for (int k = 0; k < ne; k++)
		{
		  maxvar.array[k] =
		    (maxvar.array[k] >
		     gridn[ii][jj][kk].array[k] ? maxvar.
		     array[k] : gridn[ii][jj][kk].array[k]);
		  minvar.array[k] =
		    (minvar.array[k] <
		     gridn[ii][jj][kk].array[k] ? minvar.
		     array[k] : gridn[ii][jj][kk].array[k]);
		}
	    }
	}
      grid = gridn.copy ();
#endif
      /* Boundary Conditions */
      rc = boundary (grid, inject_jet);
      /* End Boundary Conditions */

      cout << setiosflags (ios::fixed);
      for (int k = 0; k < ne; k++)
	{
	  cout << k +
	    1 << " " << maxvar.array[k] << " " << minvar.array[k] << endl;
	}


      if (timestep % printtime == 0)
	{
	  // cout << "outputting " << endl;
	  rc = output (grid, fx, fy, timestep, "out_2d_");
	}
      if (time > maxtime)
	{
	  rc = output (grid, fx, fy, timestep, "out_2d_");
	  break;
	}

      /* ------------- */
      /* End of loop through timestep */
    }
  /* ------------- */





  end = clock ();
  elapsed = ((double) (end - start)) / CLOCKS_PER_SEC;
  cout << "\n\n Elapsed time = " << elapsed << " sec\n\n" << endl;


  return 0;
}
Exemplo n.º 2
0
void PerformanceTesting::TestMaxSpeed(std::ostream & info_output, std::ostream & error_output)
{
	info_output << "Testing top speed" << std::endl;

	float maxtime = 300;
	float t = 0.;
	float dt = 1/90.0;
	int i = 0;

	std::pair <float, float> maxspeed(0, 0);
	float maxlift = 0;
	float maxdrag = 0;
	float lastsecondspeed = 0;
	float stopthreshold = 0.001; //if the accel (in m/s^2) is less than this value, discontinue the testing

	float timeto60start = 0; //don't start the 0-60 clock until the car is moving at a threshold speed to account for the crappy launch that the autoclutch gives
	float timeto60startthreshold = 1; //threshold speed to start 0-60 clock in m/s
	float timeto60 = maxtime;

	float timetoquarter = maxtime;
	float quarterspeed = 0;

	ResetCar();

	clock_t cpu_timer_start = clock();
	while (t < maxtime)
	{
		if (car.GetTransmission().GetGear() == 1 &&
			car.GetEngine().GetRPM() > 0.8f * car.GetEngine().GetRedline())
		{
			carinput[CarInput::BRAKE] = 0;
			carinput[CarInput::CLUTCH] = 0;
		}

		car.Update(carinput);

		world.update(dt);

		float car_speed = car.GetSpeed();
		if (car_speed > maxspeed.second)
		{
			maxspeed.first = t;
			maxspeed.second = car_speed;
			maxlift = car.GetTotalAero()[2];
			maxdrag = car.GetTotalAero()[1];
		}

		if (car_speed < timeto60startthreshold)
			timeto60start = t;

		if (car_speed < 26.8224f)
			timeto60 = t;

		if (car.GetCenterOfMass().length() > 402.3f && timetoquarter == maxtime)
		{
			//quarter mile!
			timetoquarter = t - timeto60start;
			quarterspeed = car_speed;
		}

		if (i % (int)(1/dt) == 0) //every second
		{
			if (car_speed - lastsecondspeed < stopthreshold && car_speed > 26)
			{
				//info_output << "Maximum speed attained at " << maxspeed.first << " s" << std::endl;
				break;
			}

			if (t > 0 && !car.GetEngine().GetCombustion())
			{
				error_output << "Car stalled during launch, t=" << t << std::endl;
			}

			lastsecondspeed = car_speed;
			//std::cout << t << ", " << car_speed << ", " << car.GetGear() << ", " << car.GetEngineRPM() << std::endl;
		}

		t += dt;
		i++;
	}
	clock_t cpu_timer_stop = clock();
	clock_t clock_ticks = cpu_timer_stop - cpu_timer_start;
	float sim_perf = (clock_ticks > 0) ? t / clock_ticks * CLOCKS_PER_SEC : 0;

	info_output << "Top speed: " << ConvertToMPH(maxspeed.second) << " MPH at " << maxspeed.first << " s\n";
	info_output << "Downforce at top speed: " << -maxlift << " N\n";
	info_output << "Drag at top speed: " << -maxdrag << " N\n";
	info_output << "0-60 MPH time: " << timeto60 - timeto60start << " s\n";
	info_output << "1/4 mile time: " << timetoquarter << " s at " << ConvertToMPH(quarterspeed) << " MPH" << std::endl;
	info_output << "Simulation performance: " << sim_perf << std::endl;
}