CALbyte calRunCAStep2D(struct CALRun2D* simulation)
{
if (simulation->globalTransition)
{
simulation->globalTransition(simulation->ca2D);
if (simulation->UPDATE_MODE == CAL_UPDATE_IMPLICIT)
calUpdate2D(simulation->ca2D);
}
else
calGlobalTransitionFunction2D(simulation->ca2D);
//No explicit substates and active cells updates are needed in this case
if (simulation->steering)
{
simulation->steering(simulation->ca2D);
if (simulation->UPDATE_MODE == CAL_UPDATE_IMPLICIT)
calUpdate2D(simulation->ca2D);
}
if (simulation->stopCondition)
if (simulation->stopCondition(simulation->ca2D))
return CAL_FALSE;
return CAL_TRUE;
}
void simulationInitialize(struct CALModel2D* model) {
//dichiarazioni
unsigned int maximum_number_of_emissions = 0;
//azzeramento dello step dell'AC
sciara->step = 0;
sciara->elapsed_time = 0;
//determinazione numero massimo di passi
for (unsigned int i = 0; i < sciara->emission_rate.size(); i++)
if (maximum_number_of_emissions < sciara->emission_rate[i].size())
maximum_number_of_emissions = sciara->emission_rate[i].size();
//maximum_steps_from_emissions = (int)(emission_time/Pclock*maximum_number_of_emissions);
sciara->parameters.effusion_duration = sciara->parameters.emission_time * maximum_number_of_emissions;
//definisce il bordo della morfologia
MakeBorder();
//calcolo a b (parametri viscosit�) c d (parametri resistenza al taglio)
evaluatePowerLawParams(sciara->parameters.Pr_Tsol, sciara->parameters.Pr_Tvent, sciara->parameters.a, sciara->parameters.b);
evaluatePowerLawParams(sciara->parameters.Phc_Tsol, sciara->parameters.Phc_Tvent, sciara->parameters.c, sciara->parameters.d);
// updateVentsEmission(model);
if (active)
for (unsigned int k = 0; k < sciara->vent.size(); k++) {
int xVent = sciara->vent[k].x();
int yVent = sciara->vent[k].y();
calAddActiveCell2D(model, yVent, xVent);
}
calUpdate2D(model);
}
void sciddicaTSimulationInit(struct CALModel2D* s3hex)
{
int i, j;
//s3hex parameters setting
P.adh = P_ADH;
P.rl = P_RL;
P.r = P_R;
P.f = P_F;
P.mt = P_MT;
P.pef = P_PEF;
// P.ltt = P_LTT;
//initializing debris source
calInitSubstate2Dr(s3hex, Q.h, 0);
calInitSubstate2Dr(s3hex, Q.p, 0);
#ifdef ACTIVE_CELLS
for (i=0; i<s3hex->rows; i++)
for (j=0; j<s3hex->columns; j++)
if (calGet2Dr(s3hex,Q.h,i,j) > P.adh) {
calAddActiveCell2D(s3hex,i,j);
}
#endif
//Substates and active cells update
calUpdate2D(s3hex);
}
void calRunInitSimulation2D(struct CALRun2D* simulation)
{
if (simulation->init)
{
simulation->init(simulation->ca2D);
if (simulation->UPDATE_MODE == CAL_UPDATE_IMPLICIT)
calUpdate2D(simulation->ca2D);
}
}
void calRunFinalizeSimulation2D(struct CALRun2D* simulation)
{
if (simulation->finalize)
{
simulation->finalize(simulation->ca2D);
if (simulation->UPDATE_MODE == CAL_UPDATE_IMPLICIT)
calUpdate2D(simulation->ca2D);
}
}
int main(int argc, char** argv)
{
// read from argv the number of steps
int steps;
if (sscanf (argv[2], "%i", &steps)!=1 && steps >=0) {
printf ("number of steps is not an integer");
exit(-1);
}
// read from argv the number of loops
if (sscanf (argv[3], "%i", &numberOfLoops)!=1 && numberOfLoops >=0) {
printf ("number of loops is not an integer");
exit(-1);
}
int platform;
if (sscanf (argv[4], "%i", &platform)!=1 && platform >=0) {
printf ("platform number is not an integer");
exit(-1);
}
int deviceNumber;
if (sscanf (argv[5], "%i", &deviceNumber)!=1 && deviceNumber >=0) {
printf ("device number is not an integer");
exit(-1);
}
struct CALCLDeviceManager * calcl_device_manager;
CALCLcontext context;
CALCLdevice device;
CALCLprogram program;
struct CALCLModel2D * device_CA;
#ifdef ACTIVE_CELLS
char * kernelSrc = KERNEL_SRC_AC;
char * kernelInc = KERNEL_INC_AC;
#else
char * kernelSrc = KERNEL_SRC;
char * kernelInc = KERNEL_INC;
#endif
CALCLkernel kernel_elem_proc_flow_computation;
CALCLkernel kernel_elem_proc_width_update;
CALCLkernel kernel_elem_proc_rm_act_cells;
CALCLkernel kernel_steering;
CALCLmem * buffersKernelFlowComp;
CALCLmem bufferEpsilonParameter;
CALCLmem bufferRParameter;
calcl_device_manager = calclCreateManager();
//calclGetPlatformAndDeviceFromStdIn(calcl_device_manager, &device);
device = calclGetDevice(calcl_device_manager, platform, deviceNumber);
context = calclCreateContext(&device);
program = calclLoadProgram2D(context, device, kernelSrc, kernelInc);
// Define of the host-side CA objects
#ifdef ACTIVE_CELLS
host_CA = calCADef2D(ROWS, COLS, CAL_VON_NEUMANN_NEIGHBORHOOD_2D, CAL_SPACE_TOROIDAL, CAL_OPT_ACTIVE_CELLS_NAIVE);
#else
host_CA = calCADef2D(ROWS, COLS, CAL_VON_NEUMANN_NEIGHBORHOOD_2D, CAL_SPACE_TOROIDAL, CAL_NO_OPT);
#endif
// Add substates
Q.f[0] = calAddSubstate2Dr(host_CA);
Q.f[1] = calAddSubstate2Dr(host_CA);
Q.f[2] = calAddSubstate2Dr(host_CA);
Q.f[3] = calAddSubstate2Dr(host_CA);
Q.z = calAddSubstate2Dr(host_CA);
Q.h = calAddSubstate2Dr(host_CA);
// Load configuration
calLoadSubstate2Dr(host_CA, Q.z, DEM_PATH);
calLoadSubstate2Dr(host_CA, Q.h, SOURCE_PATH);
// Initialization
sciddicaTSimulationInit(host_CA);
calUpdate2D(host_CA);
// Define a device-side CA
device_CA = calclCADef2D(host_CA, context, program, device);
//Set the workgroup dimensions
calclSetWorkGroupDimensions(device_CA, 8, 8);
// Extract kernels from program
kernel_elem_proc_flow_computation = calclGetKernelFromProgram(&program, KERNEL_ELEM_PROC_FLOW_COMPUTATION);
kernel_elem_proc_width_update = calclGetKernelFromProgram(&program, KERNEL_ELEM_PROC_WIDTH_UPDATE);
#ifdef ACTIVE_CELLS
kernel_elem_proc_rm_act_cells = calclGetKernelFromProgram(&program, KERNEL_ELEM_PROC_RM_ACT_CELLS);
#endif
kernel_steering = calclGetKernelFromProgram(&program, KERNEL_STEERING);
bufferEpsilonParameter = calclCreateBuffer(context, &P.epsilon, sizeof(CALParameterr));
bufferRParameter = calclCreateBuffer(context, &P.r, sizeof(CALParameterr));
calclSetKernelArg2D(&kernel_elem_proc_flow_computation, 0, sizeof(CALCLmem), &bufferEpsilonParameter);
calclSetKernelArg2D(&kernel_elem_proc_flow_computation, 1, sizeof(CALCLmem), &bufferRParameter);
calclSetKernelArg2D(&kernel_elem_proc_flow_computation, 2, sizeof(int), &numberOfLoops);
calclSetKernelArg2D(&kernel_elem_proc_width_update, 0, sizeof(int), &numberOfLoops);
// Register transition function's elementary processes kernels
calclAddElementaryProcess2D(device_CA, &kernel_elem_proc_flow_computation);
calclAddElementaryProcess2D(device_CA, &kernel_elem_proc_width_update);
calclAddSteeringFunc2D(device_CA, &kernel_steering);
#ifdef ACTIVE_CELLS
calclSetKernelArg2D(&kernel_elem_proc_rm_act_cells, 0, sizeof(CALCLmem), &bufferEpsilonParameter);
calclAddElementaryProcess2D(device_CA, &kernel_elem_proc_rm_act_cells);
#endif
// Simulation run
struct OpenCALTime * opencalTime= (struct OpenCALTime *)malloc(sizeof(struct OpenCALTime));
startTime(opencalTime);
calclRun2D(device_CA, 1, steps);
endTime(opencalTime);
// Saving results
calSaveSubstate2Dr(host_CA, Q.h,"./testsout/other/1.txt");
// Finalizations
calclFinalizeManager(calcl_device_manager);
calclFinalize2D(device_CA);
calFinalize2D(host_CA);
return 0;
}
