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; }