World *readWorld(char *file_path) {
FILE *in = fopen(file_path, "rb");
if (!in) {
fprintf(stderr, "Error reading %s: file not found\n", file_path);
return NULL;
}
unsigned int size;
fread(&size, sizeof(size), 1, in);
World *world = createWorld(size);
for (int i = 0; i < world->num_chunks; i++) {
if (!readChunk(world->chunks[i], in)) {
freeWorld(world);
fclose(in);
return NULL;
}
}
fclose(in);
return world;
}
void freeScene(Scene * scene)
{
freeCamera(scene->camera);
freeWorld(scene->world);
freeWater(scene->water);
free(scene->context);
free(scene);
glfwTerminate();
}
/**
* unitTest
*
* This subroutine emulates a Roomba in the grid world defined by world
* It receives an action from the supervisor and updates the world map with its
* location. This allows us to determine the next set of sensor data to return
* to the supervisor.
*
* @arg command This is a command from the supervisor
* @arg needCleanup Use as Boolean, if TRUE then test is over and need to free memory
*
* @return char* a string containing fake sensor data
*/
char* unitTest(int command, int needCleanup)
{
// Check if we've completed the unit test and need to clean up
if(needCleanup)
{
freeWorld();
return NULL;
}//if
return doMove(command);
}//unitTest
int main(int argc, char **argv)
{
bool keepGoing = true;
srand(time(NULL)); //seed random generator
parseArguments(argc, argv);
allocWorld();
fillWorld();
Timer renderTimer = makeTimer(1.0 / config.framerate);
if (config.render)
initRender();
if (config.measureSamples < 0) {
/* Loop forever, or until the user quits the renderer */
while (stepSimulation(&renderTimer));
} else {
printf("Waiting for system to relax.\n");
for (double t = 0; keepGoing && t < config.measureWait; t += config.timeStep) {
keepGoing = stepSimulation(&renderTimer);
if (fmod(t, config.measureWait / 100) < config.timeStep) {
printf("\rRelax time %13f of %f",
(t + config.measureWait/100) / TIME_FACTOR,
config.measureWait / TIME_FACTOR);
fflush(stdout);
}
}
/* Perform the measurements */
printf("\nStarting measurement.\n");
FILE *outstream = fopen(DATA_FILE_NAME, "w");
//plotHeader(outstream);
double intervalTime = 0;
for (long sample = 0; keepGoing && sample < config.measureSamples; sample++) {
while (keepGoing && intervalTime <= config.measureInterval) {
keepGoing = stepSimulation(&renderTimer);
intervalTime += config.timeStep;
}
if (!keepGoing)
break;
/* Check for numerical drift (or bugs) before
* commiting measurement. */
if (!physicsCheck())
die("You broke physics!\n");
dumpEnergies(outstream);
printf("\rMeasured sample %ld/%ld", sample + 1, config.measureSamples);
fflush(stdout);
intervalTime -= config.measureInterval;
}
printf("\n");
fclose(outstream);
}
freeWorld();
return 0;
}
int main(int argc, char **argv)
{
seedRandom();
parseArguments(argc, argv);
const char *filenameBase = measurementConf.measureFile;
allocWorld(1, worldSize);
fillStrand(&world.strands[0], baseSequence);
initGrid(numBoxes, worldSize);
killMomentum();
assert(worldSanityCheck());
/* Integrator config */
Integrator integrator;
integrator.type = integratorType;
switch (integratorType) {
case VERLET:
integrator.settings.verlet = verletSettings;
break;
case LANGEVIN:
integrator.settings.langevin = langevinSettings;
break;
default:
die("Unknown integrator type!\n");
}
integratorConf.integrator = integrator;
/* Measurement header */
char *measHeaderStrings[2];
measHeaderStrings[0] = getWorldInfo();
measHeaderStrings[1] = integratorInfo(&integratorConf);
char *measHeader = asprintfOrDie("%s%s",
measHeaderStrings[0], measHeaderStrings[1]);
free(measHeaderStrings[0]); free(measHeaderStrings[1]);
measurementConf.measureHeader = measHeader;
/* Integrator task */
Task integratorTask = makeIntegratorTask(&integratorConf);
/* Verbose task */
Measurement verbose;
verbose.measConf = verboseConf;
verbose.sampler = dumpStatsSampler();
Task verboseTask = measurementTask(&verbose);
/* Diffusion task */
Measurement diffusion;
diffusion.sampler = strandCOMSquaredDisplacementSampler(&world.strands[0]);
diffusion.measConf = measurementConf;
Task diffusionTask = measurementTask(&diffusion);
/* End to end task */
char *endToEndFile = asprintfOrDie("%s%s", filenameBase,
END_TO_END_DIST_FILE_SUFFIX);
Measurement endToEnd;
endToEnd.sampler = endToEndDistSampler(&world.strands[0]);
endToEnd.measConf = measurementConf; /* struct copy */
endToEnd.measConf.measureFile = endToEndFile;
endToEnd.measConf.verbose = false; /* Let output come from
diffusion sampler */
Task endToEndTask = measurementTask(&endToEnd);
/* Temperature task */
char *temperatureFile = asprintfOrDie("%s%s", filenameBase,
TEMPERATURE_FILE_SUFFIX);
Measurement tempMeas;
tempMeas.sampler = temperatureSampler();
tempMeas.measConf = measurementConf; /* struct copy */
tempMeas.measConf.measureFile = temperatureFile;
tempMeas.measConf.verbose = false; /* Let output come from
diffusion sampler */
Task temperatureTask = measurementTask(&tempMeas);
/* Render task */
Task renderTask = makeRenderTask(&renderConf);
/* Combined task */
Task *tasks[6];
tasks[0] = (render ? &renderTask : NULL);
tasks[1] = &integratorTask;
tasks[2] = &verboseTask;
tasks[3] = &diffusionTask;
tasks[4] = (measureEndToEndDistance ? &endToEndTask : NULL);
tasks[5] = (measureTemperature ? &temperatureTask : NULL);
Task task = sequence(tasks, 6);
setHeatBathTemperature(temperature);
registerInteractions(interactionSettings);
bool everythingOK = run(&task);
freeWorld();
free(endToEndFile);
free(temperatureFile);
free(measHeader);
if (!everythingOK)
return 1;
return 0;
}
