int main() { realtype abstol=ATOL, reltol=RTOL, t, tout; N_Vector c; WebData wdata; void *cvode_mem; booleantype firstrun; int jpre, gstype, flag; int ns, mxns, iout; c = NULL; wdata = NULL; cvode_mem = NULL; /* Initializations */ c = N_VNew_Serial(NEQ); if(check_flag((void *)c, "N_VNew_Serial", 0)) return(1); wdata = AllocUserData(); if(check_flag((void *)wdata, "AllocUserData", 2)) return(1); InitUserData(wdata); ns = wdata->ns; mxns = wdata->mxns; /* Print problem description */ PrintIntro(); /* Loop over jpre and gstype (four cases) */ for (jpre = PREC_LEFT; jpre <= PREC_RIGHT; jpre++) { for (gstype = MODIFIED_GS; gstype <= CLASSICAL_GS; gstype++) { /* Initialize c and print heading */ CInit(c, wdata); PrintHeader(jpre, gstype); /* Call CVodeInit or CVodeReInit, then CVSpgmr to set up problem */ firstrun = (jpre == PREC_LEFT) && (gstype == MODIFIED_GS); if (firstrun) { cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON); if(check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1); wdata->cvode_mem = cvode_mem; flag = CVodeSetUserData(cvode_mem, wdata); if(check_flag(&flag, "CVodeSetUserData", 1)) return(1); flag = CVodeInit(cvode_mem, f, T0, c); if(check_flag(&flag, "CVodeInit", 1)) return(1); flag = CVodeSStolerances(cvode_mem, reltol, abstol); if (check_flag(&flag, "CVodeSStolerances", 1)) return(1); flag = CVSpgmr(cvode_mem, jpre, MAXL); if(check_flag(&flag, "CVSpgmr", 1)) return(1); flag = CVSpilsSetGSType(cvode_mem, gstype); if(check_flag(&flag, "CVSpilsSetGSType", 1)) return(1); flag = CVSpilsSetEpsLin(cvode_mem, DELT); if(check_flag(&flag, "CVSpilsSetEpsLin", 1)) return(1); flag = CVSpilsSetPreconditioner(cvode_mem, Precond, PSolve); if(check_flag(&flag, "CVSpilsSetPreconditioner", 1)) return(1); } else { flag = CVodeReInit(cvode_mem, T0, c); if(check_flag(&flag, "CVodeReInit", 1)) return(1); flag = CVSpilsSetPrecType(cvode_mem, jpre); check_flag(&flag, "CVSpilsSetPrecType", 1); flag = CVSpilsSetGSType(cvode_mem, gstype); if(check_flag(&flag, "CVSpilsSetGSType", 1)) return(1); } /* Print initial values */ if (firstrun) PrintAllSpecies(c, ns, mxns, T0); /* Loop over output points, call CVode, print sample solution values. */ tout = T1; for (iout = 1; iout <= NOUT; iout++) { flag = CVode(cvode_mem, tout, c, &t, CV_NORMAL); PrintOutput(cvode_mem, t); if (firstrun && (iout % 3 == 0)) PrintAllSpecies(c, ns, mxns, t); if(check_flag(&flag, "CVode", 1)) break; if (tout > RCONST(0.9)) tout += DTOUT; else tout *= TOUT_MULT; } /* Print final statistics, and loop for next case */ PrintFinalStats(cvode_mem); } } /* Free all memory */ CVodeFree(&cvode_mem); N_VDestroy_Serial(c); FreeUserData(wdata); return(0); }
int main() { realtype abstol, reltol, t, tout; N_Vector u; UserData data; void *cvode_mem; int iout, flag; u = NULL; data = NULL; cvode_mem = NULL; /* Allocate memory, and set problem data, initial values, tolerances */ u = N_VNew_Serial(NEQ); if(check_flag((void *)u, "N_VNew_Serial", 0)) return(1); data = AllocUserData(); if(check_flag((void *)data, "AllocUserData", 2)) return(1); InitUserData(data); SetInitialProfiles(u, data->dx, data->dy); abstol=ATOL; reltol=RTOL; /* Call CvodeCreate to create the solver memory CV_BDF specifies the Backward Differentiation Formula CV_NEWTON specifies a Newton iteration A pointer to the integrator memory is returned and stored in cvode_mem. */ cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON); if(check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1); /* Set the pointer to user-defined data */ flag = CVodeSetFdata(cvode_mem, data); if(check_flag(&flag, "CVodeSetFdata", 1)) return(1); /* Call CVodeMalloc to initialize the integrator memory: f is the user's right hand side function in u'=f(t,u) T0 is the initial time u is the initial dependent variable vector CV_SS specifies scalar relative and absolute tolerances reltol is the relative tolerance &abstol is a pointer to the scalar absolute tolerance */ flag = CVodeMalloc(cvode_mem, f, T0, u, CV_SS, reltol, &abstol); if(check_flag(&flag, "CVodeMalloc", 1)) return(1); /* Call CVSpgmr to specify the linear solver CVSPGMR with left preconditioning and the maximum Krylov dimension maxl */ flag = CVSpgmr(cvode_mem, PREC_LEFT, 0); if(check_flag(&flag, "CVSpgmr", 1)) return(1); /* Set modified Gram-Schmidt orthogonalization, preconditioner setup and solve routines Precond and PSolve, and the pointer to the user-defined block data */ flag = CVSpgmrSetGSType(cvode_mem, MODIFIED_GS); if(check_flag(&flag, "CVSpgmrSetGSType", 1)) return(1); flag = CVSpgmrSetPreconditioner(cvode_mem, Precond, PSolve, data); if(check_flag(&flag, "CVSpgmrSetPreconditioner", 1)) return(1); /* In loop over output points, call CVode, print results, test for error */ printf(" \n2-species diurnal advection-diffusion problem\n\n"); for (iout=1, tout = TWOHR; iout <= NOUT; iout++, tout += TWOHR) { flag = CVode(cvode_mem, tout, u, &t, CV_NORMAL); PrintOutput(cvode_mem, u, t); if(check_flag(&flag, "CVode", 1)) break; } PrintFinalStats(cvode_mem); /* Free memory */ N_VDestroy_Serial(u); FreeUserData(data); CVodeFree(cvode_mem); return(0); }
int main() { realtype fnormtol, scsteptol; N_Vector y, scale, constraints; int mset, flag, i; void *kmem; SUNMatrix J; SUNLinearSolver LS; y = scale = constraints = NULL; kmem = NULL; J = NULL; LS = NULL; printf("\nRobot Kinematics Example\n"); printf("8 variables; -1 <= x_i <= 1\n"); printf("KINSOL problem size: 8 + 2*8 = 24 \n\n"); /* Create vectors for solution, scales, and constraints */ y = N_VNew_Serial(NEQ); if (check_flag((void *)y, "N_VNew_Serial", 0)) return(1); scale = N_VNew_Serial(NEQ); if (check_flag((void *)scale, "N_VNew_Serial", 0)) return(1); constraints = N_VNew_Serial(NEQ); if (check_flag((void *)constraints, "N_VNew_Serial", 0)) return(1); /* Initialize and allocate memory for KINSOL */ kmem = KINCreate(); if (check_flag((void *)kmem, "KINCreate", 0)) return(1); flag = KINInit(kmem, func, y); /* y passed as a template */ if (check_flag(&flag, "KINInit", 1)) return(1); /* Set optional inputs */ N_VConst_Serial(ZERO,constraints); for (i = NVAR+1; i <= NEQ; i++) Ith(constraints, i) = ONE; flag = KINSetConstraints(kmem, constraints); if (check_flag(&flag, "KINSetConstraints", 1)) return(1); fnormtol = FTOL; flag = KINSetFuncNormTol(kmem, fnormtol); if (check_flag(&flag, "KINSetFuncNormTol", 1)) return(1); scsteptol = STOL; flag = KINSetScaledStepTol(kmem, scsteptol); if (check_flag(&flag, "KINSetScaledStepTol", 1)) return(1); /* Create dense SUNMatrix */ J = SUNDenseMatrix(NEQ, NEQ); if(check_flag((void *)J, "SUNDenseMatrix", 0)) return(1); /* Create dense SUNLinearSolver object */ LS = SUNLinSol_Dense(y, J); if(check_flag((void *)LS, "SUNLinSol_Dense", 0)) return(1); /* Attach the matrix and linear solver to KINSOL */ flag = KINSetLinearSolver(kmem, LS, J); if(check_flag(&flag, "KINSetLinearSolver", 1)) return(1); /* Set the Jacobian function */ flag = KINSetJacFn(kmem, jac); if (check_flag(&flag, "KINSetJacFn", 1)) return(1); /* Indicate exact Newton */ mset = 1; flag = KINSetMaxSetupCalls(kmem, mset); if (check_flag(&flag, "KINSetMaxSetupCalls", 1)) return(1); /* Initial guess */ N_VConst_Serial(ONE, y); for(i = 1; i <= NVAR; i++) Ith(y,i) = SUNRsqrt(TWO)/TWO; printf("Initial guess:\n"); PrintOutput(y); /* Call KINSol to solve problem */ N_VConst_Serial(ONE,scale); flag = KINSol(kmem, /* KINSol memory block */ y, /* initial guess on input; solution vector */ KIN_LINESEARCH, /* global strategy choice */ scale, /* scaling vector, for the variable cc */ scale); /* scaling vector for function values fval */ if (check_flag(&flag, "KINSol", 1)) return(1); printf("\nComputed solution:\n"); PrintOutput(y); /* Print final statistics and free memory */ PrintFinalStats(kmem); N_VDestroy_Serial(y); N_VDestroy_Serial(scale); N_VDestroy_Serial(constraints); KINFree(&kmem); SUNLinSolFree(LS); SUNMatDestroy(J); return(0); }
int do_integrate(float t_start, float t_stop, int n_points) { realtype reltol, t; N_Vector y, abstol; void *cvode_mem; int flag, flagr, iout; y = abstol = NULL; cvode_mem = NULL; /* Create serial vector of length NEQ for I.C. and abstol */ y = N_VNew_Serial(NEQ); if (check_flag((void *)y, "N_VNew_Serial", 0)) return(1); abstol = N_VNew_Serial(NEQ); if (check_flag((void *)abstol, "N_VNew_Serial", 0)) return(1); //Setup the initial state values: setup_initial_states(y); setup_tolerances(abstol); /* Set the scalar relative tolerance */ reltol = RTOL; /* Call CVodeCreate to create the solver memory and specify the * Backward Differentiation Formula and the use of a Newton iteration */ cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON); if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1); /* Call CVodeInit to initialize the integrator memory and specify the * user's right hand side function in y'=f(t,y), the inital time T0, and * the initial dependent variable vector y. */ flag = CVodeInit(cvode_mem, f, t_start, y); if (check_flag(&flag, "CVodeInit", 1)) return(1); /* Call CVodeSVtolerances to specify the scalar relative tolerance * and vector absolute tolerances */ flag = CVodeSVtolerances(cvode_mem, reltol, abstol); if (check_flag(&flag, "CVodeSVtolerances", 1)) return(1); /* Call CVDense to specify the CVDENSE dense linear solver */ flag = CVDense(cvode_mem, NEQ); if (check_flag(&flag, "CVDense", 1)) return(1); /* Set the Jacobian routine to Jac (user-supplied) */ flag = CVDlsSetDenseJacFn(cvode_mem, Jac); if (check_flag(&flag, "CVDlsSetDenseJacFn", 1)) return(1); /* In loop, call CVode, print results, and test for error.*/ printf(" \n3-species kinetics problem\n\n"); iout = 0; int i=0; for(i=1;i< n_points; i++) { float t_next = t_start + (t_stop-t_start)/n_points * i; printf("Advancing to: %f", t_next); flag = CVode(cvode_mem, t_next, y, &t, CV_NORMAL); loop_function(t,y); PrintOutput(t, Ith(y,1), Ith(y,2), Ith(y,3)); //printf("MH: %d %f",iout,t_next); if (check_flag(&flag, "CVode", 1)) break; assert(flag==CV_SUCCESS); } /* Print some final statistics */ PrintFinalStats(cvode_mem); /* Free y and abstol vectors */ N_VDestroy_Serial(y); N_VDestroy_Serial(abstol); /* Free integrator memory */ CVodeFree(&cvode_mem); return(0); }
VkResult setup(VkDevice device, VkCommandPool command_pool, SwapChain& swap_chain, uint32_t *width, uint32_t *height) { VkCommandBuffer setup_command_buffer = VK_NULL_HANDLE; // command buffer used for setup VkCommandBufferAllocateInfo command_buffer_allocate_info; command_buffer_allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; command_buffer_allocate_info.pNext = nullptr; command_buffer_allocate_info.commandPool = command_pool; command_buffer_allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; command_buffer_allocate_info.commandBufferCount = 1; vkAllocateCommandBuffers(device, &command_buffer_allocate_info, &setup_command_buffer); VkCommandBufferBeginInfo command_buffer_begin_info = {}; command_buffer_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; command_buffer_begin_info.pNext = nullptr; command_buffer_begin_info.flags = 0; command_buffer_begin_info.pInheritanceInfo = nullptr; vkBeginCommandBuffer(setup_command_buffer, &command_buffer_begin_info); // SWAP CHAIN uint32_t present_mode_count = 0; vkGetPhysicalDeviceSurfacePresentModesKHR(swap_chain.gpu, swap_chain.surface, &present_mode_count, nullptr); std::vector<VkPresentModeKHR> present_modes(present_mode_count); vkGetPhysicalDeviceSurfacePresentModesKHR(swap_chain.gpu, swap_chain.surface, &present_mode_count, present_modes.data()); // Try to use mailbox mode // Low latency and non-tearing VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR; for (uint32_t i = 0; i < present_mode_count; i++) { if (present_modes[i] == VK_PRESENT_MODE_MAILBOX_KHR) { swapchainPresentMode = VK_PRESENT_MODE_MAILBOX_KHR; break; } if ((swapchainPresentMode != VK_PRESENT_MODE_MAILBOX_KHR) && (present_modes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR)) { swapchainPresentMode = VK_PRESENT_MODE_IMMEDIATE_KHR; } } VkSurfaceCapabilitiesKHR surface_cap; vkGetPhysicalDeviceSurfaceCapabilitiesKHR(swap_chain.gpu, swap_chain.surface, &surface_cap); VkExtent2D swapchainExtent = {}; // width and height are either both -1, or both not -1. if (surface_cap.currentExtent.width == -1) { // If the surface size is undefined, the size is set to // the size of the images requested. swapchainExtent.width = *width; swapchainExtent.height = *height; } else { // If the surface size is defined, the swap chain size must match swapchainExtent = surface_cap.currentExtent; *width = surface_cap.currentExtent.width; *height = surface_cap.currentExtent.height; } // Determine the number of images uint32_t desired_number_of_swapchain_images = surface_cap.minImageCount + 1; if ((surface_cap.maxImageCount > 0) && (desired_number_of_swapchain_images > surface_cap.maxImageCount)) { desired_number_of_swapchain_images = surface_cap.maxImageCount; } VkSurfaceTransformFlagsKHR pre_transform; if (check_flag(surface_cap.supportedTransforms, VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR)) { pre_transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; } else { pre_transform = surface_cap.currentTransform; } /* VkSwapchainCreateInfoKHR swapchain_creation_info = {}; swapchain_creation_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; swapchain_creation_info.pNext = NULL; swapchain_creation_info.surface = surface; swapchain_creation_info.minImageCount = desired_number_of_swapchain_images; swapchain_creation_info.imageFormat = colorFormat; swapchain_creation_info.imageColorSpace = colorSpace; swapchain_creation_info.imageExtent = { swapchainExtent.width, swapchainExtent.height }; swapchain_creation_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; swapchain_creation_info.preTransform = (VkSurfaceTransformFlagBitsKHR)preTransform; swapchain_creation_info.imageArrayLayers = 1; swapchain_creation_info.queueFamilyIndexCount = VK_SHARING_MODE_EXCLUSIVE; swapchain_creation_info.queueFamilyIndexCount = 0; swapchain_creation_info.pQueueFamilyIndices = NULL; swapchain_creation_info.presentMode = swapchainPresentMode; swapchain_creation_info.oldSwapchain = VK_NULL_HANDLE; swapchain_creation_info.clipped = true; swapchain_creation_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; vkCreateSwapchainKHR(device, &swapchain_creation_info, nullptr, &swap_chain.swap_chain); std::vector<VkImage> swap_chain_images(desired_number_of_swapchain_images); vkGetSwapchainImagesKHR(device, swapChain, &desired_number_of_swapchain_images, swap_chain_images.data()); */ /* assert(!err); buffers = (SwapChainBuffer*)malloc(sizeof(SwapChainBuffer)*imageCount); assert(buffers); //buffers.resize(imageCount); for (uint32_t i = 0; i < imageCount; i++) { VkImageViewCreateInfo colorAttachmentView = {}; colorAttachmentView.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; colorAttachmentView.pNext = NULL; colorAttachmentView.format = colorFormat; colorAttachmentView.components = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A }; colorAttachmentView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; colorAttachmentView.subresourceRange.baseMipLevel = 0; colorAttachmentView.subresourceRange.levelCount = 1; colorAttachmentView.subresourceRange.baseArrayLayer = 0; colorAttachmentView.subresourceRange.layerCount = 1; colorAttachmentView.viewType = VK_IMAGE_VIEW_TYPE_2D; colorAttachmentView.flags = 0; buffers[i].image = swapchainImages[i]; vkTools::setImageLayout( cmdBuffer, buffers[i].image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR); colorAttachmentView.image = buffers[i].image; err = vkCreateImageView(device, &colorAttachmentView, nullptr, &buffers[i].view); assert(!err); } */ vkEndCommandBuffer(setup_command_buffer); VkSubmitInfo submit_info = {}; submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; submit_info.pNext = nullptr; submit_info.waitSemaphoreCount = 0; submit_info.pWaitSemaphores = nullptr; submit_info.pWaitDstStageMask = nullptr; submit_info.commandBufferCount = 1; submit_info.pCommandBuffers = &setup_command_buffer; submit_info.signalSemaphoreCount = 0; submit_info.pSignalSemaphores = nullptr; vkQueueSubmit(swap_chain.present_queue, 1, &submit_info, VK_NULL_HANDLE); vkQueueWaitIdle(swap_chain.present_queue); vkFreeCommandBuffers(device, command_pool, 1, &setup_command_buffer); return VK_SUCCESS; }
int main(int argc, char *argv[]) { MPI_Comm comm; void *mem; UserData data; long int SystemSize, local_N, mudq, mldq, mukeep, mlkeep; realtype rtol, atol, t0, tout, tret; N_Vector uv, uvp, resid, id; int thispe, npes, maxl, iout, retval; uv = uvp = resid = id = NULL; data = NULL; mem = NULL; /* Set communicator, and get processor number and total number of PE's. */ MPI_Init(&argc, &argv); comm = MPI_COMM_WORLD; MPI_Comm_rank(comm, &thispe); MPI_Comm_size(comm, &npes); if (npes != NPEX*NPEY) { if (thispe == 0) fprintf(stderr, "\nMPI_ERROR(0): npes = %d not equal to NPEX*NPEY = %d\n", npes, NPEX*NPEY); MPI_Finalize(); return(1); } /* Set local length (local_N) and global length (SystemSize). */ local_N = MXSUB*MYSUB*NUM_SPECIES; SystemSize = NEQ; /* Set up user data block data. */ data = (UserData) malloc(sizeof *data); InitUserData(data, thispe, npes, comm); /* Create needed vectors, and load initial values. The vector resid is used temporarily only. */ uv = N_VNew_Parallel(comm, local_N, SystemSize); if(check_flag((void *)uv, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1); uvp = N_VNew_Parallel(comm, local_N, SystemSize); if(check_flag((void *)uvp, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1); resid = N_VNew_Parallel(comm, local_N, SystemSize); if(check_flag((void *)resid, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1); id = N_VNew_Parallel(comm, local_N, SystemSize); if(check_flag((void *)id, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1); SetInitialProfiles(uv, uvp, id, resid, data); /* Set remaining inputs to IDAS. */ t0 = ZERO; rtol = RTOL; atol = ATOL; /* Call IDACreate and IDAInit to initialize solution */ mem = IDACreate(); if(check_flag((void *)mem, "IDACreate", 0, thispe)) MPI_Abort(comm, 1); retval = IDASetUserData(mem, data); if(check_flag(&retval, "IDASetUserData", 1, thispe)) MPI_Abort(comm, 1); retval = IDASetId(mem, id); if(check_flag(&retval, "IDASetId", 1, thispe)) MPI_Abort(comm, 1); retval = IDAInit(mem, res, t0, uv, uvp); if(check_flag(&retval, "IDAInit", 1, thispe)) MPI_Abort(comm, 1); retval = IDASStolerances(mem, rtol, atol); if(check_flag(&retval, "IDASStolerances", 1, thispe)) MPI_Abort(comm, 1); /* Call IDASpgmr to specify the IDAS LINEAR SOLVER IDASPGMR */ maxl = 16; retval = IDASpgmr(mem, maxl); if(check_flag(&retval, "IDASpgmr", 1, thispe)) MPI_Abort(comm, 1); /* Call IDABBDPrecInit to initialize the band-block-diagonal preconditioner. The half-bandwidths for the difference quotient evaluation are exact for the system Jacobian, but only a 5-diagonal band matrix is retained. */ mudq = mldq = NSMXSUB; mukeep = mlkeep = 2; retval = IDABBDPrecInit(mem, local_N, mudq, mldq, mukeep, mlkeep, ZERO, reslocal, NULL); if(check_flag(&retval, "IDABBDPrecInit", 1, thispe)) MPI_Abort(comm, 1); /* Call IDACalcIC (with default options) to correct the initial values. */ tout = RCONST(0.001); retval = IDACalcIC(mem, IDA_YA_YDP_INIT, tout); if(check_flag(&retval, "IDACalcIC", 1, thispe)) MPI_Abort(comm, 1); retval = IDAGetConsistentIC(mem, uv, uvp); if(check_flag(&retval, "IDAGetConsistentIC", 1, thispe)) MPI_Abort(comm, 1); /* On PE 0, print heading, basic parameters, initial values. */ if (thispe == 0) PrintHeader(SystemSize, maxl, mudq, mldq, mukeep, mlkeep, rtol, atol); PrintOutput(mem, uv, t0, data, comm); /* Call IDAS in tout loop, normal mode, and print selected output. */ for (iout = 1; iout <= NOUT; iout++) { retval = IDASolve(mem, tout, &tret, uv, uvp, IDA_NORMAL); if(check_flag(&retval, "IDASolve", 1, thispe)) MPI_Abort(comm, 1); PrintOutput(mem, uv, tret, data, comm); if (iout < 3) tout *= TMULT; else tout += TADD; } /* Print each PE's portion of the solution in a separate file. */ /* PrintSol(mem, uv, uvp, data, comm); */ /* On PE 0, print final set of statistics. */ if (thispe == 0) { PrintFinalStats(mem); } /* Free memory. */ N_VDestroy_Parallel(uv); N_VDestroy_Parallel(uvp); N_VDestroy_Parallel(id); N_VDestroy_Parallel(resid); IDAFree(&mem); free(data); MPI_Finalize(); return(0); }
void Ida::initialize() { _properties = dynamic_cast<ISystemProperties*>(_system); _continuous_system = dynamic_cast<IContinuous*>(_system); _event_system = dynamic_cast<IEvent*>(_system); _mixed_system = dynamic_cast<IMixedSystem*>(_system); _time_system = dynamic_cast<ITime*>(_system); IGlobalSettings* global_settings = dynamic_cast<ISolverSettings*>(_idasettings)->getGlobalSettings(); // Kennzeichnung, dass initialize()() (vor der Integration) aufgerufen wurde _idid = 5000; _tLastEvent = 0.0; _event_n = 0; SolverDefaultImplementation::initialize(); _dimStates = _continuous_system->getDimContinuousStates(); _dimZeroFunc = _event_system->getDimZeroFunc()+_event_system->getDimClock(); _dimAE = _continuous_system->getDimAE(); if(_dimAE>0) _dimSys=_dimAE+ _dimStates; else _dimSys=_dimStates; if (_dimStates <= 0) { _idid = -1; throw std::invalid_argument("Ida::initialize()"); } else { // Allocate state vectors, stages and temporary arrays /*if (_z) delete[] _z; if (_zInit) delete[] _zInit; if (_zWrite) delete[] _zWrite;*/ if (_y) delete[] _y; if (_yInit) delete[] _yInit; if (_yWrite) delete[] _yWrite; if (_ypWrite) delete[] _ypWrite; if (_yp) delete[] _yp; if (_dae_res) delete[] _dae_res; if (_zeroSign) delete[] _zeroSign; if (_absTol) delete[] _absTol; if(_delta) delete [] _delta; if(_deltaInv) delete [] _deltaInv; if(_ysave) delete [] _ysave; _y = new double[_dimSys]; _yp = new double[_dimSys]; _yInit = new double[_dimSys]; _yWrite = new double[_dimSys]; _ypWrite = new double[_dimSys]; _dae_res = new double[_dimSys]; /* _z = new double[_dimSys]; _zInit = new double[_dimSys]; _zWrite = new double[_dimSys]; */ _zeroSign = new int[_dimZeroFunc]; _absTol = new double[_dimSys]; _delta =new double[_dimSys]; _deltaInv =new double[_dimSys]; _ysave =new double[_dimSys]; memset(_y, 0, _dimSys * sizeof(double)); memset(_yp, 0, _dimSys * sizeof(double)); memset(_yInit, 0, _dimSys * sizeof(double)); memset(_ysave, 0, _dimSys * sizeof(double)); std::fill_n(_absTol, _dimSys, 1.0); // Counter initialisieren _outStps = 0; if (_idasettings->getDenseOutput()) { // Ausgabeschrittweite _hOut = global_settings->gethOutput(); } // Allocate memory for the solver _idaMem = IDACreate(); if (check_flag((void*) _idaMem, "IDACreate", 0)) { _idid = -5; throw std::invalid_argument(/*_idid,_tCurrent,*/"Ida::initialize()"); } // // Make Ida ready for integration // // Set initial values for IDA //_continuous_system->evaluateAll(IContinuous::CONTINUOUS); _continuous_system->getContinuousStates(_yInit); memcpy(_y, _yInit, _dimStates * sizeof(double)); if(_dimAE>0) { _mixed_system->getAlgebraicDAEVars(_yInit+_dimStates); memcpy(_y+_dimStates, _yInit+_dimStates, _dimAE * sizeof(double)); _continuous_system->getContinuousStates(_yp); } // Get nominal values _continuous_system->getNominalStates(_absTol); for (int i = 0; i < _dimStates; i++) _absTol[i] = dynamic_cast<ISolverSettings*>(_idasettings)->getATol(); _CV_y0 = N_VMake_Serial(_dimSys, _yInit); _CV_y = N_VMake_Serial(_dimSys, _y); _CV_yp = N_VMake_Serial(_dimSys, _yp); _CV_yWrite = N_VMake_Serial(_dimSys, _yWrite); _CV_ypWrite = N_VMake_Serial(_dimSys, _ypWrite); _CV_absTol = N_VMake_Serial(_dimSys, _absTol); if (check_flag((void*) _CV_y0, "N_VMake_Serial", 0)) { _idid = -5; throw std::invalid_argument("Ida::initialize()"); } //is already initialized: calcFunction(_tCurrent, NV_DATA_S(_CV_y0), NV_DATA_S(_CV_yp),NV_DATA_S(_CV_yp)); // Initialize Ida (Initial values are required) _idid = IDAInit(_idaMem, rhsFunctionCB, _tCurrent, _CV_y0, _CV_yp); if (_idid < 0) { _idid = -5; throw std::invalid_argument("Ida::initialize()"); } _idid = IDASetErrHandlerFn(_idaMem, errOutputIDA, _data); if (_idid < 0) throw std::invalid_argument("IDA::initialize()"); // Set Tolerances _idid = IDASVtolerances(_idaMem, dynamic_cast<ISolverSettings*>(_idasettings)->getRTol(), _CV_absTol); // RTOL and ATOL if (_idid < 0) throw std::invalid_argument("IDA::initialize()"); // Set the pointer to user-defined data _idid = IDASetUserData(_idaMem, _data); if (_idid < 0) throw std::invalid_argument("IDA::initialize()"); _idid = IDASetInitStep(_idaMem, 1e-6); // INITIAL STEPSIZE if (_idid < 0) throw std::invalid_argument("Ida::initialize()"); _idid = IDASetMaxStep(_idaMem, global_settings->getEndTime() / 10.0); // MAXIMUM STEPSIZE if (_idid < 0) throw std::invalid_argument("IDA::initialize()"); _idid = IDASetMaxNonlinIters(_idaMem, 5); // Max number of iterations if (_idid < 0) throw std::invalid_argument("IDA::initialize()"); _idid = IDASetMaxErrTestFails(_idaMem, 100); if (_idid < 0) throw std::invalid_argument("IDA::initialize()"); _idid = IDASetMaxNumSteps(_idaMem, 1e3); // Max Number of steps if (_idid < 0) throw std::invalid_argument(/*_idid,_tCurrent,*/"IDA::initialize()"); // Initialize linear solver _idid = IDADense(_idaMem, _dimSys); if (_idid < 0) throw std::invalid_argument("IDA::initialize()"); if(_dimAE>0) { _idid = IDASetSuppressAlg(_idaMem, TRUE); double* tmp = new double[_dimSys]; std::fill_n(tmp, _dimStates, 1.0); std::fill_n(tmp+_dimStates, _dimAE, 0.0); _idid = IDASetId(_idaMem, N_VMake_Serial(_dimSys,tmp)); delete [] tmp; if (_idid < 0) throw std::invalid_argument("IDA::initialize()"); } // Use own jacobian matrix //_idid = CVDlsSetDenseJacFn(_idaMem, &jacobianFunctionCB); //if (_idid < 0) // throw std::invalid_argument("IDA::initialize()"); if (_dimZeroFunc) { _idid = IDARootInit(_idaMem, _dimZeroFunc, &zeroFunctionCB); memset(_zeroSign, 0, _dimZeroFunc * sizeof(int)); _idid = IDASetRootDirection(_idaMem, _zeroSign); if (_idid < 0) throw std::invalid_argument(/*_idid,_tCurrent,*/"IDA::initialize()"); memset(_zeroSign, -1, _dimZeroFunc * sizeof(int)); memset(_zeroVal, -1, _dimZeroFunc * sizeof(int)); } _ida_initialized = true; // // IDA is ready for integration // // BOOST_LOG_SEV(ida_lg::get(), ida_info) << "IDA initialized"; } }
void attrib_u_char(char **str, t_var **var, int count[3]) { int nbr; int s_nbr; int flag; char c; int k; int check; int neg; k = 0; c = 't'; neg = 0; nbr = ft_nbrlen(var[count[2]]->u_carac); flag = check_flag(str, count, &nbr, &c); check = ft_atoi_ultra(str[count[0]]); if (str[count[0]][0] == '.') nbr--; str[count[0]] = (char *)malloc(sizeof(char) * (nbr * 5)); str[count[0]] = ft_ntoa_base_un(var[count[2]]->u_carac, "0123456789"); s_nbr = ft_strlen(str[count[0]]); if (flag == 1000) { neg = 1; str[count[0]] = ft_strjoin("+", str[count[0]]); } else if (flag == 2000) str[count[0]] = ft_strjoin(" ", str[count[0]]); else if (flag == 4000) { str[count[0]] = ft_strjoin("+", str[count[0]]); while (k < check - s_nbr) { str[count[0]] = ft_strjoin(str[count[0]], " "); k++; } } else if (flag == 3000) { if (var[count[2]]->stars < 0) { while (k > var[count[2]]->stars + nbr - 1) { str[count[0]] = ft_strjoin(str[count[0]], " "); k--; } } else { while (k < var[count[2]]->stars - nbr + 1) { str[count[0]] = ft_strjoin(" ", str[count[0]]); k++; } } } else if (flag != 1 && flag != 1000 && flag != 2000 && flag != 3000 && flag != 5000) { if (flag < -1 && c != '0') { while (k > flag + s_nbr + neg) { str[count[0]] = ft_strjoin(str[count[0]], " "); k--; } } else if (flag > 0 && (c == '0' || c == '.')) { while (k < flag - s_nbr - neg) { str[count[0]] = ft_strjoin("0", str[count[0]]); k++; } } else if (flag < -1 && c == '0') { while (k > flag) { str[count[0]] = ft_strjoin("0", str[count[0]]); k--; } } else { while (k < flag - s_nbr - neg) { str[count[0]] = ft_strjoin(" ", str[count[0]]); k++; } } } count[2]++; }
void attrib_x_maj_short(char **str, t_var **var, int count[3]) { int nbr; int flag; int k; int l; char c; k = 0; c = 't'; nbr = ft_nbrlen(var[count[2]]->u_short); l = ft_atoi_spec_o(str[count[0]]); flag = check_flag(str, count, &nbr, &c); str[count[0]] = ft_ntoa_base_un(var[count[2]]->u_short, "0123456789ABCDEF"); nbr = ft_strlen(str[count[0]]); if (flag == 1000) str[count[0]] = ft_strjoin("+", str[count[0]]); else if (flag == 2000) str[count[0]] = ft_strjoin(" ", str[count[0]]); else if (flag == 5000) { str[count[0]] = ft_strjoin("0x", str[count[0]]); flag = l; nbr++; } else if (flag == 3000) { if (var[count[2]]->stars < 0) { while (k > var[count[2]]->stars + nbr - 1) { str[count[0]] = ft_strjoin(str[count[0]], " "); k--; } } else { while (k < var[count[2]]->stars - nbr + 1) { str[count[0]] = ft_strjoin(" ", str[count[0]]); k++; } } } if (flag != -1 && flag != 1000 && flag != 2000 && flag != 3000 && flag != 5000) { if (flag < -1 && c != '0') { while (k > flag + nbr) { str[count[0]] = ft_strjoin(str[count[0]], " "); k--; } } else if (flag > 0 && (c == '0' || c == '.')) { while (k < flag - nbr) { str[count[0]] = ft_strjoin("0", str[count[0]]); k++; } } else if (flag < -1 && c == '0') { while (k > flag) { str[count[0]] = ft_strjoin("0", str[count[0]]); k--; } } else { while (k < flag - nbr) { str[count[0]] = ft_strjoin(" ", str[count[0]]); k++; } } } if (c != '.' && c != '0') { while (str[count[0]][0] == '0' && str[count[0]][1] != '\0') str[count[0]] = ft_strsub(str[count[0]], 1, ft_strlen(str[count[0]])); } count[2]++; }
int main(void) { void *mem; UserData data; N_Vector uu, up, constraints, id, res; int ier, iout; long int mu, ml, netf, ncfn; realtype rtol, atol, t0, t1, tout, tret; mem = NULL; data = NULL; uu = up = constraints = id = res = NULL; /* Create vectors uu, up, res, constraints, id. */ uu = N_VNew_Serial(NEQ); if(check_flag((void *)uu, "N_VNew_Serial", 0)) return(1); up = N_VNew_Serial(NEQ); if(check_flag((void *)up, "N_VNew_Serial", 0)) return(1); res = N_VNew_Serial(NEQ); if(check_flag((void *)res, "N_VNew_Serial", 0)) return(1); constraints = N_VNew_Serial(NEQ); if(check_flag((void *)constraints, "N_VNew_Serial", 0)) return(1); id = N_VNew_Serial(NEQ); if(check_flag((void *)id, "N_VNew_Serial", 0)) return(1); /* Create and load problem data block. */ data = (UserData) malloc(sizeof *data); if(check_flag((void *)data, "malloc", 2)) return(1); data->mm = MGRID; data->dx = ONE/(MGRID - ONE); data->coeff = ONE/( (data->dx) * (data->dx) ); /* Initialize uu, up, id. */ SetInitialProfile(data, uu, up, id, res); /* Set constraints to all 1's for nonnegative solution values. */ N_VConst(ONE, constraints); /* Set remaining input parameters. */ t0 = ZERO; t1 = RCONST(0.01); rtol = ZERO; atol = RCONST(1.0e-3); /* Call IDACreate and IDAMalloc to initialize solution */ mem = IDACreate(); if(check_flag((void *)mem, "IDACreate", 0)) return(1); ier = IDASetUserData(mem, data); if(check_flag(&ier, "IDASetUserData", 1)) return(1); ier = IDASetId(mem, id); if(check_flag(&ier, "IDASetId", 1)) return(1); ier = IDASetConstraints(mem, constraints); if(check_flag(&ier, "IDASetConstraints", 1)) return(1); N_VDestroy_Serial(constraints); ier = IDAInit(mem, heatres, t0, uu, up); if(check_flag(&ier, "IDAInit", 1)) return(1); ier = IDASStolerances(mem, rtol, atol); if(check_flag(&ier, "IDASStolerances", 1)) return(1); /* Call IDABand to specify the linear solver. */ mu = MGRID; ml = MGRID; ier = IDABand(mem, NEQ, mu, ml); if(check_flag(&ier, "IDABand", 1)) return(1); /* Call IDACalcIC to correct the initial values. */ ier = IDACalcIC(mem, IDA_YA_YDP_INIT, t1); if(check_flag(&ier, "IDACalcIC", 1)) return(1); /* Print output heading. */ PrintHeader(rtol, atol); PrintOutput(mem, t0, uu); /* Loop over output times, call IDASolve, and print results. */ for (tout = t1, iout = 1; iout <= NOUT; iout++, tout *= TWO) { ier = IDASolve(mem, tout, &tret, uu, up, IDA_NORMAL); if(check_flag(&ier, "IDASolve", 1)) return(1); PrintOutput(mem, tret, uu); } /* Print remaining counters and free memory. */ ier = IDAGetNumErrTestFails(mem, &netf); check_flag(&ier, "IDAGetNumErrTestFails", 1); ier = IDAGetNumNonlinSolvConvFails(mem, &ncfn); check_flag(&ier, "IDAGetNumNonlinSolvConvFails", 1); printf("\n netf = %ld, ncfn = %ld \n", netf, ncfn); IDAFree(&mem); N_VDestroy_Serial(uu); N_VDestroy_Serial(up); N_VDestroy_Serial(id); N_VDestroy_Serial(res); free(data); return(0); }
void attrib_d_char(char **str, t_var **var, int count[3]) { int nbr; int flag; char c; int k; int check; int check_double; int neg; k = 0; c = 't'; neg = 0; nbr = ft_nbrlen(var[count[2]]->carac); flag = check_flag(str, count, &nbr, &c); check = ft_atoi_ultra(str[count[0]]); if (flag == 3500) check_double = ft_atoi_double(str[count[0]]); if (str[count[0]][0] == '.' && var[count[2]]->carac < 0) nbr--; str[count[0]] = ft_ntoa_base(var[count[2]]->carac, "0123456789"); if (var[count[2]]->carac < 0 && str[count[0]][0] != '0') neg = 1; if (flag == 1000 && var[count[2]]->carac >= 0) { neg = 1; str[count[0]] = ft_strjoin("+", str[count[0]]); } else if (flag == 3500) { if (var[count[2]]->carac < 0) { str[count[0]] = ft_strsub(str[count[0]], 1, ft_nbrlen(var[count[2]]->carac) + 1); while (k < check_double - nbr - 1) { str[count[0]] = ft_strjoin("0", str[count[0]]); k++; } k = 0; str[count[0]] = ft_strjoin("-", str[count[0]]); while (k < check - check_double) { str[count[0]] = ft_strjoin(" ", str[count[0]]); k++; } } else { while (k < check_double - nbr) { str[count[0]] = ft_strjoin("0", str[count[0]]); k++; } k = 0; while (k < check - check_double) { str[count[0]] = ft_strjoin(" ", str[count[0]]); k++; } } } else if (flag == 2000 && var[count[2]]->carac >= 0) str[count[0]] = ft_strjoin(" ", str[count[0]]); else if (flag == 4000) { if (var[count[2]]->carac >= 0) str[count[0]] = ft_strjoin("+", str[count[0]]); while (k < check - nbr) { str[count[0]] = ft_strjoin(str[count[0]], " "); k++; } } else if (flag == 3000) { if (var[count[2]]->stars < 0) { while (k > var[count[2]]->stars + nbr - 1) { str[count[0]] = ft_strjoin(str[count[0]], " "); k--; } } else { while (k < var[count[2]]->stars - nbr + 1) { str[count[0]] = ft_strjoin(" ", str[count[0]]); k++; } } } else if (flag != 1 && flag != 1000 && flag != 2000 && flag != 3000 && flag != 4000 && flag != 3500 && flag != 5000) { if (flag < -1 && c != '0') { while (k > flag + nbr + neg) { str[count[0]] = ft_strjoin(str[count[0]], " "); k--; } } else if (flag > 0 && (c == '0' || c == '.')) { if (var[count[2]]->carac < 0) str[count[0]] = ft_strsub(str[count[0]], 1, ft_nbrlen(var[count[2]]->entier) + 1); while (k < flag - nbr - neg) { str[count[0]] = ft_strjoin("0", str[count[0]]); k++; } if (var[count[2]]->carac < 0) str[count[0]] = ft_strjoin("-", str[count[0]]); } else if (flag < -1 && c == '0') { while (k > flag) { str[count[0]] = ft_strjoin("0", str[count[0]]); k--; } } else { while (k < flag - nbr - neg) { str[count[0]] = ft_strjoin(" ", str[count[0]]); k++; } } } count[2]++; }
static int simulate_nmr_pulse(struct bloch_sim *bs) { N_Vector M = NULL; M = N_VNew_Serial(3 * bs->num_cells); if (check_flag((void *)M, "N_VNew_Serial", 0)) return(1); int i; /* Set initial (t=0) magnetization conditions */ for(i=0; i < bs->num_cells; ++i) { X(M,i) = 0.0; Y(M,i) = 0.0; Z(M,i) = bs->cell_frequencies[i] / bs->w_avg; } realtype reltol = RCONST(1.0e-14); realtype abstol = RCONST(1.0e-14); void *cvode_mem = CVodeCreate(CV_ADAMS, CV_FUNCTIONAL); if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1); int flag; //TODO: check if flag should be pointer; flag = CVodeInit(cvode_mem, bloch_equations, 0.0, M); if (check_flag(&flag, "CVodeInit", 1)) return(1); flag = CVodeSetUserData(cvode_mem, bs); if (check_flag(&flag, "CVodeSetUserData", 1)) return(1); flag = CVodeSStolerances(cvode_mem, reltol, abstol); if (check_flag(&flag, "CVodeSetUserData", 1)) return(1); flag = CVDense(cvode_mem, 3 * bs->num_cells); if (check_flag(&flag, "CVDense", 1)) return(1); flag = CVDlsSetDenseJacFn(cvode_mem, bloch_jacobian); if (check_flag(&flag, "CVDlsSetDenseJacFn", 1)) return(1); /////////////////////////// // PI/2 PULSE SIMULATION // /////////////////////////// bs->rf_on = 1; flag = CVodeSetStopTime(cvode_mem, bs->pi2_duration); if (check_flag(&flag, "CVodeSetStopTime", 1)) return 1; realtype time_reached; flag = CVode(cvode_mem, bs->pi2_duration, M, &time_reached, CV_NORMAL); if (flag != CV_SUCCESS) { printf("ERROR: Failed to simulate Pi/2 pulse\n"); } // {{{ PI2 PULSE DEBUG STATEMENTS if (DEBUG) { printf("\n"); printf("#####################################\n"); printf("### PI/2 PULSE SIMULATION DETAILS ###\n"); printf("#####################################\n"); printf("\n"); printf("TIME REACHED: %.15e\n", time_reached); printf("TIME REACHED - PI2_DURATION: %.15e\n", time_reached - bs->pi2_duration); printf("\n"); printf("MAGNETIZATION AT END OF PI/2 PULSE:\n"); for (i = 0; i<bs->num_cells; ++i) { printf("CELL %d: %.4e, %.4e, %.4e\n", i, X(M,i), Y(M,i), Z(M,i)); } } // }}} //////////////////// // FID SIMULATION // //////////////////// bs->rf_on = 0; if (DEBUG) { printf("##############################\n"); printf("### FID SIMULATION DETAILS ###\n"); printf("##############################\n"); } flag = CVodeReInit(cvode_mem, 0.0, M); if (check_flag(&flag, "CVodeReInit", 1)) return(1); time_reached = 0.0; flag = CVodeSetStopTime(cvode_mem, bs->fid_duration); if (check_flag(&flag, "CVodeSetStopTime", 1)) return 1; flag = CVodeRootInit(cvode_mem, 1, bloch_root); if (check_flag(&flag, "CVodeRootInit", 1)) return 1; realtype time_desired, M_FID_X; while (time_reached < bs->fid_duration) { time_desired = time_reached + bs->fid_sampling_interval; flag = CVode(cvode_mem, time_desired, M, &time_reached, CV_NORMAL); if (flag == CV_ROOT_RETURN) { bs->zero_crossings[bs->num_zero_crossings] = time_reached; M_FID_X = 0.0; for (i=0; i < bs->num_cells; i++) { M_FID_X += X(M,i) * cos(bs->w_avg * time_reached); M_FID_X += Y(M,i) * sin(bs->w_avg * time_reached); } bs->envelope[bs->num_zero_crossings] = M_FID_X / bs->num_cells; bs->num_zero_crossings++; } } bs->zero_crossings = (realtype*) realloc(bs->zero_crossings, sizeof(realtype) * bs->num_zero_crossings); bs->envelope = (realtype*) realloc(bs->envelope, sizeof(realtype) * bs->num_zero_crossings); if (!bs->zero_crossings || !bs->envelope) { printf("ERROR: reallocating zero crossing and/or envelope array memory failed!\n"); exit(1); } N_VDestroy_Serial(M); CVodeFree(&cvode_mem); return 0; }
/* This routine generates the block-diagonal part of the Jacobian corresponding to the interaction rates, multiplies by -gamma, adds the identity matrix, and calls denseGETRF to do the LU decomposition of each diagonal block. The computation of the diagonal blocks uses the preset block and grouping information. One block per group is computed. The Jacobian elements are generated by difference quotients using calls to the routine fblock. This routine can be regarded as a prototype for the general case of a block-diagonal preconditioner. The blocks are of size mp, and there are ngrp=ngx*ngy blocks computed in the block-grouping scheme. */ static int Precond(realtype t, N_Vector c, N_Vector fc, booleantype jok, booleantype *jcurPtr, realtype gamma, void *user_data, N_Vector vtemp1, N_Vector vtemp2, N_Vector vtemp3) { realtype ***P; long int **pivot, ier; int i, if0, if00, ig, igx, igy, j, jj, jx, jy; int *jxr, *jyr, ngrp, ngx, ngy, mxmp, flag; long int mp; realtype uround, fac, r, r0, save, srur; realtype *f1, *fsave, *cdata, *rewtdata; WebData wdata; void *cvode_mem; N_Vector rewt; wdata = (WebData) user_data; cvode_mem = wdata->cvode_mem; cdata = N_VGetArrayPointer_Serial(c); rewt = wdata->rewt; flag = CVodeGetErrWeights(cvode_mem, rewt); if(check_flag(&flag, "CVodeGetErrWeights", 1)) return(1); rewtdata = N_VGetArrayPointer_Serial(rewt); uround = UNIT_ROUNDOFF; P = wdata->P; pivot = wdata->pivot; jxr = wdata->jxr; jyr = wdata->jyr; mp = wdata->mp; srur = wdata->srur; ngrp = wdata->ngrp; ngx = wdata->ngx; ngy = wdata->ngy; mxmp = wdata->mxmp; fsave = wdata->fsave; /* Make mp calls to fblock to approximate each diagonal block of Jacobian. Here, fsave contains the base value of the rate vector and r0 is a minimum increment factor for the difference quotient. */ f1 = N_VGetArrayPointer_Serial(vtemp1); fac = N_VWrmsNorm (fc, rewt); r0 = RCONST(1000.0)*SUNRabs(gamma)*uround*NEQ*fac; if (r0 == ZERO) r0 = ONE; for (igy = 0; igy < ngy; igy++) { jy = jyr[igy]; if00 = jy*mxmp; for (igx = 0; igx < ngx; igx++) { jx = jxr[igx]; if0 = if00 + jx*mp; ig = igx + igy*ngx; /* Generate ig-th diagonal block */ for (j = 0; j < mp; j++) { /* Generate the jth column as a difference quotient */ jj = if0 + j; save = cdata[jj]; r = SUNMAX(srur*SUNRabs(save),r0/rewtdata[jj]); cdata[jj] += r; fac = -gamma/r; fblock (t, cdata, jx, jy, f1, wdata); for (i = 0; i < mp; i++) { P[ig][j][i] = (f1[i] - fsave[if0+i])*fac; } cdata[jj] = save; } } } /* Add identity matrix and do LU decompositions on blocks. */ for (ig = 0; ig < ngrp; ig++) { denseAddIdentity(P[ig], mp); ier = denseGETRF(P[ig], mp, mp, pivot[ig]); if (ier != 0) return(1); } *jcurPtr = TRUE; return(0); }
static void PrintFinalStats(void *cvode_mem) { long int lenrw, leniw ; long int lenrwLS, leniwLS; long int nst, nfe, nsetups, nni, ncfn, netf; long int nli, npe, nps, ncfl, nfeLS; int flag; realtype avdim; flag = CVodeGetWorkSpace(cvode_mem, &lenrw, &leniw); check_flag(&flag, "CVodeGetWorkSpace", 1); flag = CVodeGetNumSteps(cvode_mem, &nst); check_flag(&flag, "CVodeGetNumSteps", 1); flag = CVodeGetNumRhsEvals(cvode_mem, &nfe); check_flag(&flag, "CVodeGetNumRhsEvals", 1); flag = CVodeGetNumLinSolvSetups(cvode_mem, &nsetups); check_flag(&flag, "CVodeGetNumLinSolvSetups", 1); flag = CVodeGetNumErrTestFails(cvode_mem, &netf); check_flag(&flag, "CVodeGetNumErrTestFails", 1); flag = CVodeGetNumNonlinSolvIters(cvode_mem, &nni); check_flag(&flag, "CVodeGetNumNonlinSolvIters", 1); flag = CVodeGetNumNonlinSolvConvFails(cvode_mem, &ncfn); check_flag(&flag, "CVodeGetNumNonlinSolvConvFails", 1); flag = CVSpilsGetWorkSpace(cvode_mem, &lenrwLS, &leniwLS); check_flag(&flag, "CVSpilsGetWorkSpace", 1); flag = CVSpilsGetNumLinIters(cvode_mem, &nli); check_flag(&flag, "CVSpilsGetNumLinIters", 1); flag = CVSpilsGetNumPrecEvals(cvode_mem, &npe); check_flag(&flag, "CVSpilsGetNumPrecEvals", 1); flag = CVSpilsGetNumPrecSolves(cvode_mem, &nps); check_flag(&flag, "CVSpilsGetNumPrecSolves", 1); flag = CVSpilsGetNumConvFails(cvode_mem, &ncfl); check_flag(&flag, "CVSpilsGetNumConvFails", 1); flag = CVSpilsGetNumRhsEvals(cvode_mem, &nfeLS); check_flag(&flag, "CVSpilsGetNumRhsEvals", 1); printf("\n\n Final statistics for this run:\n\n"); printf(" CVode real workspace length = %4ld \n", lenrw); printf(" CVode integer workspace length = %4ld \n", leniw); printf(" CVSPGMR real workspace length = %4ld \n", lenrwLS); printf(" CVSPGMR integer workspace length = %4ld \n", leniwLS); printf(" Number of steps = %4ld \n", nst); printf(" Number of f-s = %4ld \n", nfe); printf(" Number of f-s (SPGMR) = %4ld \n", nfeLS); printf(" Number of f-s (TOTAL) = %4ld \n", nfe + nfeLS); printf(" Number of setups = %4ld \n", nsetups); printf(" Number of nonlinear iterations = %4ld \n", nni); printf(" Number of linear iterations = %4ld \n", nli); printf(" Number of preconditioner evaluations = %4ld \n", npe); printf(" Number of preconditioner solves = %4ld \n", nps); printf(" Number of error test failures = %4ld \n", netf); printf(" Number of nonlinear conv. failures = %4ld \n", ncfn); printf(" Number of linear convergence failures = %4ld \n", ncfl); avdim = (nni > 0) ? ((realtype)nli)/((realtype)nni) : ZERO; #if defined(SUNDIALS_EXTENDED_PRECISION) printf(" Average Krylov subspace dimension = %.3Lf \n", avdim); #else printf(" Average Krylov subspace dimension = %.3f \n", avdim); #endif printf("\n\n--------------------------------------------------------------"); printf("--------------\n"); printf( "--------------------------------------------------------------"); printf("--------------\n"); }
int main(int argc, char *argv[]) { realtype abstol, reltol, t, tout; N_Vector u; UserData data; PreconData predata; void *cvode_mem; int iout, flag, my_pe, npes; long int neq, local_N; MPI_Comm comm; u = NULL; data = NULL; predata = NULL; cvode_mem = NULL; /* Set problem size neq */ neq = NVARS*MX*MY; /* Get processor number and total number of pe's */ MPI_Init(&argc, &argv); comm = MPI_COMM_WORLD; MPI_Comm_size(comm, &npes); MPI_Comm_rank(comm, &my_pe); if (npes != NPEX*NPEY) { if (my_pe == 0) fprintf(stderr, "\nMPI_ERROR(0): npes = %d is not equal to NPEX*NPEY = %d\n\n", npes,NPEX*NPEY); MPI_Finalize(); return(1); } /* Set local length */ local_N = NVARS*MXSUB*MYSUB; /* Allocate and load user data block; allocate preconditioner block */ data = (UserData) malloc(sizeof *data); if (check_flag((void *)data, "malloc", 2, my_pe)) MPI_Abort(comm, 1); InitUserData(my_pe, comm, data); predata = AllocPreconData (data); /* Allocate u, and set initial values and tolerances */ u = N_VNew_Parallel(comm, local_N, neq); if (check_flag((void *)u, "N_VNew", 0, my_pe)) MPI_Abort(comm, 1); SetInitialProfiles(u, data); abstol = ATOL; reltol = RTOL; /* Call CVodeCreate to create the solver memory: CV_BDF specifies the Backward Differentiation Formula CV_NEWTON specifies a Newton iteration A pointer to the integrator memory is returned and stored in cvode_mem. */ cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON); if (check_flag((void *)cvode_mem, "CVodeCreate", 0, my_pe)) MPI_Abort(comm, 1); /* Set the pointer to user-defined data */ flag = CVodeSetFdata(cvode_mem, data); if (check_flag(&flag, "CVodeSetFdata", 1, my_pe)) MPI_Abort(comm, 1); /* Call CVodeMalloc to initialize the integrator memory: cvode_mem is the pointer to the integrator memory returned by CVodeCreate f is the user's right hand side function in y'=f(t,y) T0 is the initial time u is the initial dependent variable vector CV_SS specifies scalar relative and absolute tolerances reltol is the relative tolerance &abstol is a pointer to the scalar absolute tolerance */ flag = CVodeMalloc(cvode_mem, f, T0, u, CV_SS, reltol, &abstol); if (check_flag(&flag, "CVodeMalloc", 1, my_pe)) MPI_Abort(comm, 1); /* Call CVSpgmr to specify the linear solver CVSPGMR with left preconditioning and the maximum Krylov dimension maxl */ flag = CVSpgmr(cvode_mem, PREC_LEFT, 0); if (check_flag(&flag, "CVSpgmr", 1, my_pe)) MPI_Abort(comm, 1); /* Set preconditioner setup and solve routines Precond and PSolve, and the pointer to the user-defined block data */ flag = CVSpilsSetPreconditioner(cvode_mem, Precond, PSolve, predata); if (check_flag(&flag, "CVSpilsSetPreconditioner", 1, my_pe)) MPI_Abort(comm, 1); if (my_pe == 0) printf("\n2-species diurnal advection-diffusion problem\n\n"); /* In loop over output points, call CVode, print results, test for error */ for (iout=1, tout = TWOHR; iout <= NOUT; iout++, tout += TWOHR) { flag = CVode(cvode_mem, tout, u, &t, CV_NORMAL); if (check_flag(&flag, "CVode", 1, my_pe)) break; PrintOutput(cvode_mem, my_pe, comm, u, t); } /* Print final statistics */ if (my_pe == 0) PrintFinalStats(cvode_mem); /* Free memory */ N_VDestroy_Parallel(u); free(data); FreePreconData(predata); CVodeFree(&cvode_mem); MPI_Finalize(); return(0); }
int main(void) { realtype abstol, reltol, t, tout; N_Vector u; UserData data; void *cvode_mem; int linsolver, iout, flag; u = NULL; data = NULL; cvode_mem = NULL; /* Allocate memory, and set problem data, initial values, tolerances */ u = N_VNew_Serial(NEQ); if(check_flag((void *)u, "N_VNew_Serial", 0)) return(1); data = AllocUserData(); if(check_flag((void *)data, "AllocUserData", 2)) return(1); InitUserData(data); SetInitialProfiles(u, data->dx, data->dy); abstol=ATOL; reltol=RTOL; /* Call CVodeCreate to create the solver memory and specify the * Backward Differentiation Formula and the use of a Newton iteration */ cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON); if(check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1); /* Set the pointer to user-defined data */ flag = CVodeSetUserData(cvode_mem, data); if(check_flag(&flag, "CVodeSetUserData", 1)) return(1); /* Call CVodeInit to initialize the integrator memory and specify the * user's right hand side function in u'=f(t,u), the inital time T0, and * the initial dependent variable vector u. */ flag = CVodeInit(cvode_mem, f, T0, u); if(check_flag(&flag, "CVodeInit", 1)) return(1); /* Call CVodeSStolerances to specify the scalar relative tolerance * and scalar absolute tolerances */ flag = CVodeSStolerances(cvode_mem, reltol, abstol); if (check_flag(&flag, "CVodeSStolerances", 1)) return(1); /* START: Loop through SPGMR, SPBCG and SPTFQMR linear solver modules */ for (linsolver = 0; linsolver < 3; ++linsolver) { if (linsolver != 0) { /* Re-initialize user data */ InitUserData(data); SetInitialProfiles(u, data->dx, data->dy); /* Re-initialize CVode for the solution of the same problem, but using a different linear solver module */ flag = CVodeReInit(cvode_mem, T0, u); if (check_flag(&flag, "CVodeReInit", 1)) return(1); } /* Attach a linear solver module */ switch(linsolver) { /* (a) SPGMR */ case(USE_SPGMR): /* Print header */ printf(" -------"); printf(" \n| SPGMR |\n"); printf(" -------\n"); /* Call CVSpgmr to specify the linear solver CVSPGMR with left preconditioning and the maximum Krylov dimension maxl */ flag = CVSpgmr(cvode_mem, PREC_LEFT, 0); if(check_flag(&flag, "CVSpgmr", 1)) return(1); /* Set modified Gram-Schmidt orthogonalization, preconditioner setup and solve routines Precond and PSolve, and the pointer to the user-defined block data */ flag = CVSpilsSetGSType(cvode_mem, MODIFIED_GS); if(check_flag(&flag, "CVSpilsSetGSType", 1)) return(1); break; /* (b) SPBCG */ case(USE_SPBCG): /* Print header */ printf(" -------"); printf(" \n| SPBCG |\n"); printf(" -------\n"); /* Call CVSpbcg to specify the linear solver CVSPBCG with left preconditioning and the maximum Krylov dimension maxl */ flag = CVSpbcg(cvode_mem, PREC_LEFT, 0); if(check_flag(&flag, "CVSpbcg", 1)) return(1); break; /* (c) SPTFQMR */ case(USE_SPTFQMR): /* Print header */ printf(" ---------"); printf(" \n| SPTFQMR |\n"); printf(" ---------\n"); /* Call CVSptfqmr to specify the linear solver CVSPTFQMR with left preconditioning and the maximum Krylov dimension maxl */ flag = CVSptfqmr(cvode_mem, PREC_LEFT, 0); if(check_flag(&flag, "CVSptfqmr", 1)) return(1); break; } /* Set preconditioner setup and solve routines Precond and PSolve, and the pointer to the user-defined block data */ flag = CVSpilsSetPreconditioner(cvode_mem, Precond, PSolve); if(check_flag(&flag, "CVSpilsSetPreconditioner", 1)) return(1); /* In loop over output points, call CVode, print results, test for error */ printf(" \n2-species diurnal advection-diffusion problem\n\n"); for (iout=1, tout = TWOHR; iout <= NOUT; iout++, tout += TWOHR) { flag = CVode(cvode_mem, tout, u, &t, CV_NORMAL); PrintOutput(cvode_mem, u, t); if(check_flag(&flag, "CVode", 1)) break; } PrintFinalStats(cvode_mem, linsolver); } /* END: Loop through SPGMR, SPBCG and SPTFQMR linear solver modules */ /* Free memory */ N_VDestroy_Serial(u); FreeUserData(data); CVodeFree(&cvode_mem); return(0); }
/* * stress_file_ioctl * stress file ioctls */ static int stress_file_ioctl(const args_t *args) { char filename[PATH_MAX]; int ret, fd; #if defined(FICLONE) || defined(FICLONERANGE) int dfd; #endif const off_t file_sz = 8192; uint32_t rnd = mwc32(); ret = stress_temp_dir_mk_args(args); if (ret < 0) return exit_status(-ret); (void)stress_temp_filename_args(args, filename, sizeof(filename), rnd); fd = open(filename, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR); if (fd < 0) { pr_err("%s: cannot create %s\n", args->name, filename); return exit_status(errno); } (void)unlink(filename); #if defined(FICLONE) || defined(FICLONERANGE) (void)stress_temp_filename_args(args, filename, sizeof(filename), rnd + 1); dfd = open(filename, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR); if (dfd < 0) { (void)close(fd); pr_err("%s: cannot create %s\n", args->name, filename); return exit_status(errno); } (void)unlink(filename); #endif (void)shim_fallocate(fd, 0, 0, file_sz); #if defined(FICLONE) || defined(FICLONERANGE) (void)shim_fallocate(dfd, 0, 0, file_sz); #endif (void)shim_fsync(fd); do { int exercised = 0; #if defined(FIOCLEX) { ret = ioctl(fd, FIOCLEX); (void)ret; exercised++; } #endif #if defined(FIONCLEX) { ret = ioctl(fd, FIONCLEX); (void)ret; exercised++; } #endif #if defined(FIONBIO) { int opt; opt = 1; ret = ioctl(fd, FIONBIO, &opt); #if defined(O_NONBLOCK) check_flag(args, "FIONBIO", fd, O_NONBLOCK, ret, true); #else (void)ret; #endif opt = 0; ret = ioctl(fd, FIONBIO, &opt); #if defined(O_NONBLOCK) check_flag(args, "FIONBIO", fd, O_NONBLOCK, ret, false); #else (void)ret; #endif exercised++; } #endif #if defined(FIOASYNC) { int opt; opt = 1; ret = ioctl(fd, FIOASYNC, &opt); #if defined(O_ASYNC) check_flag(args, "FIONASYNC", fd, O_ASYNC, ret, true); #else (void)ret; #endif opt = 0; ret = ioctl(fd, FIOASYNC, &opt); #if defined(O_ASYNC) check_flag(args, "FIONASYNC", fd, O_ASYNC, ret, false); #else (void)ret; #endif exercised++; } #endif #if defined(FIOQSIZE) { shim_loff_t sz; struct stat buf; ret = fstat(fd, &buf); if (ret == 0) { ret = ioctl(fd, FIOQSIZE, &sz); if ((ret == 0) && (file_sz != buf.st_size)) pr_fail("%s: ioctl FIOQSIZE failed, size " "%jd (filesize) vs %jd (reported)\n", args->name, (intmax_t)file_sz, (intmax_t)sz); } exercised++; } #endif /* Disable this at the moment, it is fragile */ #if 0 #if defined(FIFREEZE) && defined(FITHAW) { ret = ioctl(fd, FIFREEZE); (void)ret; ret = ioctl(fd, FITHAW); (void)ret; exercised++; } #endif #endif #if defined(FIGETBSZ) { int isz; ret = ioctl(fd, FIGETBSZ, &isz); if ((ret == 0) && (isz < 1)) pr_fail("%s: ioctl FIGETBSZ returned unusual " "block size %d\n", args->name, isz); exercised++; } #endif #if defined(FICLONE) { ret = ioctl(dfd, FICLONE, fd); (void)ret; exercised++; } #endif #if defined(FICLONERANGE) { struct file_clone_range fcr; (void)memset(&fcr, 0, sizeof(fcr)); fcr.src_fd = fd; fcr.src_offset = 0; fcr.src_length = file_sz; fcr.dest_offset = 0; ret = ioctl(dfd, FICLONERANGE, &fcr); (void)ret; exercised++; } #endif #if defined(FIDEDUPERANGE) { const size_t sz = sizeof(struct file_dedupe_range) + sizeof(struct file_dedupe_range_info); char buf[sz] ALIGNED(64); struct file_dedupe_range *d = (struct file_dedupe_range *)buf; d->src_offset = 0; d->src_length = file_sz; d->dest_count = 1; d->reserved1 = 0; d->reserved2 = 0; d->info[0].dest_fd = dfd; d->info[0].dest_offset = 0; /* Zero the return values */ d->info[0].bytes_deduped = 0; d->info[0].status = 0; d->info[0].reserved = 0; ret = ioctl(fd, FIDEDUPERANGE, d); (void)ret; exercised++; } #endif #if defined(FIONREAD) { int isz = 0; ret = ioctl(fd, FIONREAD, &isz); (void)ret; exercised++; } #endif #if defined(FIONWRITE) { int isz = 0; ret = ioctl(fd, FIONWRITE, &isz); (void)ret; exercised++; } #endif #if defined(FS_IOC_RESVSP) { unsigned long isz = file_sz * 2; ret = ioctl(fd, FS_IOC_RESVP, &isz); (void)ret; exercised++; } #endif #if defined(FS_IOC_RESVSP64) { unsigned long isz = file_sz * 2; ret = ioctl(fd, FS_IOC_RESVP64, &isz); (void)ret; exercised++; } #endif #if defined(FIBMAP) { int block = 0; ret = ioctl(fd, FIBMAP, &block); (void)ret; exercised++; } #endif if (!exercised) { pr_inf("%s: no available file ioctls to exercise\n", args->name); ret = EXIT_NOT_IMPLEMENTED; goto tidy; } inc_counter(args); } while (keep_stressing()); ret = EXIT_SUCCESS; tidy: #if defined(FICLONE) || defined(FICLONERANGE) (void)close(dfd); #endif (void)close(fd); (void)stress_temp_dir_rm_args(args); return ret; }
static int rangematch(const char *pattern, char test, int flags, const char **newp) { int negate, ok; char c, c2; char tmp; /* * A bracket expression starting with an unquoted circumflex * character produces unspecified results (IEEE 1003.2-1992, * 3.13.2). This implementation treats it like '!', for * consistency with the regular expression syntax. * J.T. Conklin ([email protected]) */ if ((negate = (*pattern == '!' || *pattern == '^'))) ++pattern; if (check_flag(flags, WM_CASEFOLD)) test = tolower((unsigned char)test); /* * A right bracket shall lose its special meaning and represent * itself in a bracket expression if it occurs first in the list. * -- POSIX.2 2.8.3.2 */ ok = 0; c = *pattern++; do { if (c == '\\' && !check_flag(flags, WM_NOESCAPE)) c = *pattern++; if (c == EOS) return RANGE_ERROR; if (c == '/' && check_flag(flags, WM_PATHNAME)) return RANGE_NOMATCH; if (*pattern == '-' && (c2 = *(pattern+1)) != EOS && c2 != ']') { pattern += 2; if (c2 == '\\' && !check_flag(flags, WM_NOESCAPE)) c2 = *pattern++; if (c2 == EOS) return RANGE_ERROR; if (check_flag(flags, WM_CASEFOLD)) { c = tolower((unsigned char)c); c2 = tolower((unsigned char)c2); } if (c > c2) { tmp = c2; c2 = c; c = tmp; } if (c <= test && test <= c2) { ok = 1; } } if (c == '[' && *pattern == ':' && *(pattern+1) != EOS) { #define match_pattern(name) \ !strncmp(pattern+1, name, sizeof(name)-1) #define check_pattern(name, predicate, value) {{ \ if (match_pattern(name ":]")) { \ if (predicate(value)) { \ ok = 1; \ } \ pattern += sizeof(name ":]"); \ continue; \ } \ }} if (match_pattern(":]")) { continue; } check_pattern("alnum", isalnum, test); check_pattern("alpha", isalpha, test); check_pattern("blank", isblank, test); check_pattern("cntrl", iscntrl, test); check_pattern("digit", isdigit, test); check_pattern("graph", isgraph, test); check_pattern("lower", islower, test); check_pattern("print", isprint, test); check_pattern("punct", ispunct, test); check_pattern("space", isspace, test); check_pattern("xdigit", isxdigit, test); c2 = check_flag(flags, WM_CASEFOLD) ? toupper(test) : test; check_pattern("upper", isupper, c2); /* fallthrough means match like a normal character */ } if (c == test) { ok = 1; } } while ((c = *pattern++) != ']'); *newp = (const char *)pattern; return (ok == negate) ? RANGE_NOMATCH : RANGE_MATCH; }
static void PrintFinalStats(void *mem) { long int nst, nre, nreLS, netf, ncfn, nni, ncfl, nli, npe, nps, nge; int flag; flag = IDAGetNumSteps(mem, &nst); check_flag(&flag, "IDAGetNumSteps", 1, 0); flag = IDAGetNumResEvals(mem, &nre); check_flag(&flag, "IDAGetNumResEvals", 1, 0); flag = IDAGetNumErrTestFails(mem, &netf); check_flag(&flag, "IDAGetNumErrTestFails", 1, 0); flag = IDAGetNumNonlinSolvConvFails(mem, &ncfn); check_flag(&flag, "IDAGetNumNonlinSolvConvFails", 1, 0); flag = IDAGetNumNonlinSolvIters(mem, &nni); check_flag(&flag, "IDAGetNumNonlinSolvIters", 1, 0); flag = IDASpilsGetNumConvFails(mem, &ncfl); check_flag(&flag, "IDASpilsGetNumConvFails", 1, 0); flag = IDASpilsGetNumLinIters(mem, &nli); check_flag(&flag, "IDASpilsGetNumLinIters", 1, 0); flag = IDASpilsGetNumPrecEvals(mem, &npe); check_flag(&flag, "IDASpilsGetNumPrecEvals", 1, 0); flag = IDASpilsGetNumPrecSolves(mem, &nps); check_flag(&flag, "IDASpilsGetNumPrecSolves", 1, 0); flag = IDASpilsGetNumResEvals(mem, &nreLS); check_flag(&flag, "IDASpilsGetNumResEvals", 1, 0); flag = IDABBDPrecGetNumGfnEvals(mem, &nge); check_flag(&flag, "IDABBDPrecGetNumGfnEvals", 1, 0); printf("-----------------------------------------------------------\n"); printf("\nFinal statistics: \n\n"); printf("Number of steps = %ld\n", nst); printf("Number of residual evaluations = %ld\n", nre+nreLS); printf("Number of nonlinear iterations = %ld\n", nni); printf("Number of error test failures = %ld\n", netf); printf("Number of nonlinear conv. failures = %ld\n\n", ncfn); printf("Number of linear iterations = %ld\n", nli); printf("Number of linear conv. failures = %ld\n\n", ncfl); printf("Number of preconditioner setups = %ld\n", npe); printf("Number of preconditioner solves = %ld\n", nps); printf("Number of local residual evals. = %ld\n", nge); }
int wildmatch(const char *pattern, const char *string, int flags) { const char *stringstart; const char *newp; const char *slash; char c, test; char prev; int wild = 0; /* WM_WILDSTAR implies WM_PATHNAME. */ if (check_flag(flags, WM_WILDSTAR)) { flags |= WM_PATHNAME; } for (stringstart = string;;) { switch (c = *pattern++) { case EOS: if (check_flag(flags, WM_LEADING_DIR) && *string == '/') return WM_MATCH; return (*string == EOS) ? WM_MATCH : WM_NOMATCH; case '?': if (*string == EOS) return WM_NOMATCH; if (*string == '/' && check_flag(flags, WM_PATHNAME)) return WM_NOMATCH; if (*string == '.' && check_flag(flags, WM_PERIOD) && (string == stringstart || (check_flag(flags, WM_PATHNAME) && *(string - 1) == '/'))) return WM_NOMATCH; ++string; break; case '*': c = *pattern; wild = check_flag(flags, WM_WILDSTAR) && c == '*'; if (wild) { prev = pattern[-2]; /* Collapse multiple stars and slash-** patterns, * e.g. "** / *** / **** / **" (without spaces) * is treated as a single ** wildstar. */ while (c == '*') { c = *++pattern; } while (c == '/' && pattern[1] == '*' && pattern[2] == '*') { prev = c; c = *++pattern; while (c == '*') { c = *++pattern; } } if (c == '/' && wildmatch(pattern+1, string, flags) == WM_MATCH) { return WM_MATCH; } } else { /* Collapse multiple stars. */ while (c == '*') { c = *++pattern; } } if (!wild && *string == '.' && check_flag(flags, WM_PERIOD) && (string == stringstart || (check_flag(flags, WM_PATHNAME) && *(string - 1) == '/'))) { return WM_NOMATCH; } /* Optimize for pattern with * or ** at end or before /. */ if (c == EOS) { if (wild && prev == '/') { return WM_MATCH; } if (check_flag(flags, WM_PATHNAME)) { return (check_flag(flags, WM_LEADING_DIR) || strchr(string, '/') == NULL ? WM_MATCH : WM_NOMATCH); } else { return WM_MATCH; } } else if (c == '/') { if (wild) { slash = strchr(stringstart, '/'); if (!slash) { return WM_NOMATCH; } while (slash) { if (wildmatch(pattern+1, slash+1, flags) == 0) { return WM_MATCH; } slash = strchr(slash+1, '/'); } } else { if (check_flag(flags, WM_PATHNAME)) { if ((string = strchr(string, '/')) == NULL) { return WM_NOMATCH; } } } } else if (wild) { return WM_NOMATCH; } /* General case, use recursion. */ while ((test = *string) != EOS) { if (!wildmatch(pattern, string, flags & ~WM_PERIOD)) return WM_MATCH; if (test == '/' && check_flag(flags, WM_PATHNAME)) break; ++string; } return WM_NOMATCH; case '[': if (*string == EOS) return WM_NOMATCH; if (*string == '/' && check_flag(flags, WM_PATHNAME)) return WM_NOMATCH; if (*string == '.' && check_flag(flags, WM_PERIOD) && (string == stringstart || (check_flag(flags, WM_PATHNAME) && *(string - 1) == '/'))) return WM_NOMATCH; switch (rangematch(pattern, *string, flags, &newp)) { case RANGE_ERROR: /* not a good range, treat as normal text */ ++string; goto normal; case RANGE_MATCH: pattern = newp; break; case RANGE_NOMATCH: return (WM_NOMATCH); } ++string; break; case '\\': if (!check_flag(flags, WM_NOESCAPE)) { if ((c = *pattern++) == EOS) { c = '\\'; --pattern; if (*(string+1) == EOS) { return WM_NOMATCH; } } } /* FALLTHROUGH */ default: normal: if (c != *string && !(check_flag(flags, WM_CASEFOLD) && (tolower((unsigned char)c) == tolower((unsigned char)*string)))) return WM_NOMATCH; ++string; break; } /* NOTREACHED */ } }
void Ida::IDACore() { _idid = IDAReInit(_idaMem, _tCurrent, _CV_y,_CV_yp); _idid = IDASetStopTime(_idaMem, _tEnd); _idid = IDASetInitStep(_idaMem, 1e-12); if (_idid < 0) throw std::runtime_error("IDA::ReInit"); bool writeEventOutput = (_settings->getGlobalSettings()->getOutputPointType() == OPT_ALL); bool writeOutput = !(_settings->getGlobalSettings()->getOutputPointType() == OPT_NONE); while ((_solverStatus & ISolver::CONTINUE) && !_interrupt ) { _cv_rt = IDASolve(_idaMem, _tEnd, &_tCurrent, _CV_y, _CV_yp, IDA_ONE_STEP); _idid = IDAGetNumSteps(_idaMem, &_locStps); if (_idid != IDA_SUCCESS) throw std::runtime_error("IDAGetNumSteps failed. The ida mem pointer is NULL"); _idid =IDAGetLastStep(_idaMem, &_h); if (_idid != IDA_SUCCESS) throw std::runtime_error("IDAGetLastStep failed. The ida mem pointer is NULL"); //Check if there was at least one output-point within the last solver interval // -> Write output if true if (writeOutput) { writeIDAOutput(_tCurrent, _h, _locStps); } #ifdef RUNTIME_PROFILING MEASURETIME_REGION_DEFINE(idaStepCompletedHandler, "IDAStepCompleted"); if(MeasureTime::getInstance() != NULL) { MEASURETIME_START(measuredFunctionStartValues, idaStepCompletedHandler, "IDAStepCompleted"); } #endif //set completed step to system and check if terminate was called if(_continuous_system->stepCompleted(_tCurrent)) _solverStatus = DONE; #ifdef RUNTIME_PROFILING if(MeasureTime::getInstance() != NULL) { MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[5], idaStepCompletedHandler); } #endif // Perform state selection bool state_selection = stateSelection(); if (state_selection) _continuous_system->getContinuousStates(_y); _zeroFound = false; // Check if step was successful if (check_flag(&_cv_rt, "IDA", 1)) { _solverStatus = ISolver::SOLVERERROR; break; } // A root was found if ((_cv_rt == IDA_ROOT_RETURN) && !isInterrupted()) { // IDA is setting _tCurrent to the time where the first event occurred double _abs = fabs(_tLastEvent - _tCurrent); _zeroFound = true; if ((_abs < 1e-3) && _event_n == 0) { _tLastEvent = _tCurrent; _event_n++; } else if ((_abs < 1e-3) && (_event_n >= 1 && _event_n < 500)) { _event_n++; } else if ((_abs >= 1e-3)) { //restart event counter _tLastEvent = _tCurrent; _event_n = 0; } else throw std::runtime_error("Number of events exceeded in time interval " + to_string(_abs) + " at time " + to_string(_tCurrent)); // IDA has interpolated the states at time 'tCurrent' _time_system->setTime(_tCurrent); // To get steep steps in the result file, two value points (P1 and P2) must be added // // Y | (P2) X........... // | : // | : // |........X (P1) // |----------------------------------> // | ^ t // _tCurrent // Write the values of (P1) if (writeEventOutput) { if(_dimAE>0) { _continuous_system->evaluateDAE(IContinuous::CONTINUOUS); } else { _continuous_system->evaluateAll(IContinuous::CONTINUOUS); } writeToFile(0, _tCurrent, _h); } _idid = IDAGetRootInfo(_idaMem, _zeroSign); for (int i = 0; i < _dimZeroFunc; i++) _events[i] = bool(_zeroSign[i]); if (_mixed_system->handleSystemEvents(_events)) { // State variables were reinitialized, thus we have to give these values to the ida-solver // Take care about the memory regions, _z is the same like _CV_y _continuous_system->getContinuousStates(_y); if(_dimAE>0) { _mixed_system->getAlgebraicDAEVars(_y+_dimStates); _continuous_system->getRHS(_yp); } calcFunction(_tCurrent, NV_DATA_S(_CV_y), NV_DATA_S(_CV_yp),_dae_res); } } if ((_zeroFound || state_selection)&& !isInterrupted()) { // Write the values of (P2) if (writeEventOutput) { // If we want to write the event-results, we should evaluate the whole system again if(_dimAE>0) { _continuous_system->evaluateDAE(IContinuous::CONTINUOUS); } else { _continuous_system->evaluateAll(IContinuous::CONTINUOUS); } writeToFile(0, _tCurrent, _h); } _idid = IDAReInit(_idaMem, _tCurrent, _CV_y,_CV_yp); if (_idid < 0) throw std::runtime_error("IDA::ReInit()"); // Der Eventzeitpunkt kann auf der Endzeit liegen (Time-Events). In diesem Fall wird der Solver beendet, da IDA sonst eine interne Warnung schmeißt if (_tCurrent == _tEnd) _cv_rt = IDA_TSTOP_RETURN; } // Zähler für die Anzahl der ausgegebenen Schritte erhöhen ++_outStps; _tLastSuccess = _tCurrent; if (_cv_rt == IDA_TSTOP_RETURN) { _time_system->setTime(_tEnd); _continuous_system->setContinuousStates(NV_DATA_S(_CV_y)); if(_dimAE>0) { _mixed_system->setAlgebraicDAEVars(NV_DATA_S(_CV_y)+_dimStates); _continuous_system->setStateDerivatives(NV_DATA_S(_CV_yp)); _continuous_system->evaluateDAE(IContinuous::CONTINUOUS); } else { _continuous_system->evaluateAll(IContinuous::CONTINUOUS); } if(writeOutput) writeToFile(0, _tEnd, _h); _accStps += _locStps; _solverStatus = DONE; } } }
int main(void) { void *mem; N_Vector yy, yp, avtol; realtype rtol, *yval, *ypval, *atval; realtype t0, t1, tout, tret; int iout, retval; mem = NULL; yy = yp = avtol = NULL; yval = ypval = atval = NULL; /* Allocate N-vectors. */ yy = N_VNew_Serial(NEQ); if(check_flag((void *)yy, "N_VNew_Serial", 0)) return(1); yp = N_VNew_Serial(NEQ); if(check_flag((void *)yp, "N_VNew_Serial", 0)) return(1); avtol = N_VNew_Serial(NEQ); if(check_flag((void *)avtol, "N_VNew_Serial", 0)) return(1); /* Create and initialize y, y', and absolute tolerance vectors. */ yval = NV_DATA_S(yy); yval[0] = ONE; yval[1] = ZERO; yval[2] = ZERO; ypval = NV_DATA_S(yp); ypval[0] = RCONST(-0.04); ypval[1] = RCONST(0.04); ypval[2] = ZERO; rtol = RCONST(1.0e-4); atval = NV_DATA_S(avtol); atval[0] = RCONST(1.0e-6); atval[1] = RCONST(1.0e-10); atval[2] = RCONST(1.0e-6); /* Integration limits */ t0 = ZERO; t1 = RCONST(0.4); PrintHeader(rtol, avtol, yy); /* Call IDACreate and IDAMalloc to initialize IDA memory */ mem = IDACreate(); if(check_flag((void *)mem, "IDACreate", 0)) return(1); retval = IDAMalloc(mem, resrob, t0, yy, yp, IDA_SV, rtol, avtol); if(check_flag(&retval, "IDAMalloc", 1)) return(1); /* Free avtol */ N_VDestroy_Serial(avtol); /* Call IDADense and set up the linear solver. */ retval = IDADense(mem, NEQ); if(check_flag(&retval, "IDADense", 1)) return(1); retval = IDADenseSetJacFn(mem, jacrob, NULL); if(check_flag(&retval, "IDADenseSetJacFn", 1)) return(1); /* Loop over tout values and call IDASolve. */ for (tout = t1, iout = 1; iout <= NOUT ; iout++, tout *= RCONST(10.0)) { retval=IDASolve(mem, tout, &tret, yy, yp, IDA_NORMAL); if(check_flag(&retval, "IDASolve", 1)) return(1); PrintOutput(mem,tret,yy); } PrintFinalStats(mem); /* Free memory */ IDAFree(mem); N_VDestroy_Serial(yy); N_VDestroy_Serial(yp); return(0); }
int main(void) { void *mem; N_Vector yy, yp, avtol; realtype rtol, *yval, *ypval, *atval; realtype t0, tout1, tout, tret; int iout, retval, retvalr; int rootsfound[2]; int nnz; mem = NULL; yy = yp = avtol = NULL; yval = ypval = atval = NULL; /* Allocate N-vectors. */ yy = N_VNew_Serial(NEQ); if(check_flag((void *)yy, "N_VNew_Serial", 0)) return(1); yp = N_VNew_Serial(NEQ); if(check_flag((void *)yp, "N_VNew_Serial", 0)) return(1); avtol = N_VNew_Serial(NEQ); if(check_flag((void *)avtol, "N_VNew_Serial", 0)) return(1); /* Create and initialize y, y', and absolute tolerance vectors. */ yval = NV_DATA_S(yy); yval[0] = ONE; yval[1] = ZERO; yval[2] = ZERO; ypval = NV_DATA_S(yp); ypval[0] = RCONST(-0.04); ypval[1] = RCONST(0.04); ypval[2] = ZERO; rtol = RCONST(1.0e-4); atval = NV_DATA_S(avtol); atval[0] = RCONST(1.0e-8); atval[1] = RCONST(1.0e-6); atval[2] = RCONST(1.0e-6); /* Integration limits */ t0 = ZERO; tout1 = RCONST(0.4); PrintHeader(rtol, avtol, yy); /* Call IDACreate and IDAMalloc to initialize IDA memory */ mem = IDACreate(); if(check_flag((void *)mem, "IDACreate", 0)) return(1); retval = IDAInit(mem, resrob, t0, yy, yp); if(check_flag(&retval, "IDAInit", 1)) return(1); retval = IDASVtolerances(mem, rtol, avtol); if(check_flag(&retval, "IDASVtolerances", 1)) return(1); /* Free avtol */ N_VDestroy_Serial(avtol); /* Call IDARootInit to specify the root function grob with 2 components */ retval = IDARootInit(mem, 2, grob); if (check_flag(&retval, "IDARootInit", 1)) return(1); /* Call IDASuperLUMT and set up the linear solver. */ nnz = NEQ * NEQ; retval = IDASuperLUMT(mem, 1, NEQ, nnz); if(check_flag(&retval, "IDASuperLUMT", 1)) return(1); retval = IDASlsSetSparseJacFn(mem, jacrob); if(check_flag(&retval, "IDASlsSetSparseJacFn", 1)) return(1); /* In loop, call IDASolve, print results, and test for error. Break out of loop when NOUT preset output times have been reached. */ iout = 0; tout = tout1; while(1) { retval = IDASolve(mem, tout, &tret, yy, yp, IDA_NORMAL); PrintOutput(mem,tret,yy); if(check_flag(&retval, "IDASolve", 1)) return(1); if (retval == IDA_ROOT_RETURN) { retvalr = IDAGetRootInfo(mem, rootsfound); check_flag(&retvalr, "IDAGetRootInfo", 1); PrintRootInfo(rootsfound[0],rootsfound[1]); } if (retval == IDA_SUCCESS) { iout++; tout *= RCONST(10.0); } if (iout == NOUT) break; } PrintFinalStats(mem); /* Free memory */ IDAFree(&mem); N_VDestroy_Serial(yy); N_VDestroy_Serial(yp); return(0); }
int main() { realtype abstol, reltol, t, tout; N_Vector u; UserData data; void *cvode_mem; int iout, flag; u = NULL; data = NULL; cvode_mem = NULL; /* Allocate memory, and set problem data, initial values, tolerances */ u = N_VNew_Serial(NEQ); if(check_flag((void *)u, "N_VNew_Serial", 0)) return(1); data = AllocUserData(); if(check_flag((void *)data, "AllocUserData", 2)) return(1); InitUserData(data); SetInitialProfiles(u, data->dx, data->dy); abstol=ATOL; reltol=RTOL; /* Call CVodeCreate to create the solver memory and specify the * Backward Differentiation Formula and the use of a Newton iteration */ cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON); if(check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1); /* Set the pointer to user-defined data */ flag = CVodeSetUserData(cvode_mem, data); if(check_flag(&flag, "CVodeSetUserData", 1)) return(1); /* Call CVodeInit to initialize the integrator memory and specify the * user's right hand side function in u'=f(t,u), the inital time T0, and * the initial dependent variable vector u. */ flag = CVodeInit(cvode_mem, f, T0, u); if(check_flag(&flag, "CVodeInit", 1)) return(1); /* Call CVodeSStolerances to specify the scalar relative tolerance * and scalar absolute tolerances */ flag = CVodeSStolerances(cvode_mem, reltol, abstol); if (check_flag(&flag, "CVodeSStolerances", 1)) return(1); /* Call CVSpgmr to specify the linear solver CVSPGMR * with left preconditioning and the maximum Krylov dimension maxl */ flag = CVSpgmr(cvode_mem, PREC_LEFT, 0); if(check_flag(&flag, "CVSpgmr", 1)) return(1); /* set the JAcobian-times-vector function */ flag = CVSpilsSetJacTimesVecFn(cvode_mem, jtv); if(check_flag(&flag, "CVSpilsSetJacTimesVecFn", 1)) return(1); /* Set the preconditioner solve and setup functions */ flag = CVSpilsSetPreconditioner(cvode_mem, Precond, PSolve); if(check_flag(&flag, "CVSpilsSetPreconditioner", 1)) return(1); /* In loop over output points, call CVode, print results, test for error */ printf(" \n2-species diurnal advection-diffusion problem\n\n"); for (iout=1, tout = TWOHR; iout <= NOUT; iout++, tout += TWOHR) { flag = CVode(cvode_mem, tout, u, &t, CV_NORMAL); PrintOutput(cvode_mem, u, t); if(check_flag(&flag, "CVode", 1)) break; } PrintFinalStats(cvode_mem); /* Free memory */ N_VDestroy_Serial(u); FreeUserData(data); CVodeFree(&cvode_mem); return(0); }
VkResult create_surface(VkInstance vk_instance, VkPhysicalDevice gpu, VkDevice* out_device, DrawCommandBuffer* out_draw_command_buffer, SwapChain* out_swap_chain) { if ((out_swap_chain == nullptr) || (out_draw_command_buffer == nullptr)) { return VK_ERROR_INITIALIZATION_FAILED; } VkWin32SurfaceCreateInfoKHR surfaceCreateInfo; surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; surfaceCreateInfo.hinstance = out_swap_chain->instance; surfaceCreateInfo.hwnd = out_swap_chain->window; VK_THROW(vkCreateWin32SurfaceKHR(vk_instance, &surfaceCreateInfo, NULL, &(out_swap_chain->surface))); uint32_t queue_count; vkGetPhysicalDeviceQueueFamilyProperties(gpu, &queue_count, nullptr); assert(queue_count > 0); std::vector<VkBool32> support_presentable_swap_chain(queue_count); std::vector<VkQueueFamilyProperties> properties(queue_count); vkGetPhysicalDeviceQueueFamilyProperties(gpu, &queue_count, properties.data()); for (uint32_t qidx = 0; qidx < queue_count; ++qidx) { vkGetPhysicalDeviceSurfaceSupportKHR(gpu, qidx, out_swap_chain->surface, &(support_presentable_swap_chain[qidx])); } uint32_t graphics_queue = UINT32_MAX; uint32_t swap_chain_queue = UINT32_MAX; for (uint32_t qidx = 0; qidx < queue_count; ++qidx) { if (check_flag(properties[qidx].queueFlags, VK_QUEUE_GRAPHICS_BIT) && properties[qidx].queueCount > 0) { graphics_queue = qidx; if (support_presentable_swap_chain[qidx]) { swap_chain_queue = qidx; break; } } } if (swap_chain_queue == UINT32_MAX) // Can't find a graphic queue that also support swap chain. Select two different queue. { for (uint32_t qidx = 0; qidx < queue_count; ++qidx) { if (support_presentable_swap_chain[qidx] && (properties[qidx].queueCount > 0)) { swap_chain_queue = qidx; break; } } } // Generate error if could not find both a graphics and a present queue if ((graphics_queue == UINT32_MAX) || (swap_chain_queue == UINT32_MAX)) { vkDestroySurfaceKHR(vk_instance, out_swap_chain->surface, nullptr); out_swap_chain->surface = nullptr; return VK_ERROR_INITIALIZATION_FAILED; } uint32_t format_count; VK_THROW(vkGetPhysicalDeviceSurfaceFormatsKHR(gpu, out_swap_chain->surface, &format_count, NULL)); std::vector<VkSurfaceFormatKHR> surface_formats(format_count); VK_THROW(vkGetPhysicalDeviceSurfaceFormatsKHR(gpu, out_swap_chain->surface, &format_count, surface_formats.data())); // If the format list includes just one entry of VK_FORMAT_UNDEFINED, // the surface has no preferred format. Otherwise, at least one // supported format will be returned if (format_count == 1 && surface_formats[0].format == VK_FORMAT_UNDEFINED) { out_swap_chain->surface_format.format = VK_FORMAT_B8G8R8A8_UNORM; out_swap_chain->surface_format.colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR; } else { assert(format_count > 0); out_swap_chain->surface_format = surface_formats[0]; } VK_THROW(create_device(gpu, graphics_queue, swap_chain_queue, out_device)); vkGetDeviceQueue(*out_device, graphics_queue, 0, &out_draw_command_buffer->draw_queue); vkGetDeviceQueue(*out_device, swap_chain_queue, 0, &out_swap_chain->present_queue); out_draw_command_buffer->queue_family_idx = graphics_queue; out_swap_chain->queue_family_idx = swap_chain_queue; out_swap_chain->gpu = gpu; return VK_SUCCESS; }
static int make_node(lua_State *L) { td_engine * const self = td_check_engine(L, 1); td_node *node = td_page_alloc(&self->alloc, sizeof(td_node)); td_noderef *noderef; node->annotation = copy_string_field(L, self, 2, "annotation"); if (strlen(node->annotation) ==0) luaL_error(L, "annotation must not be empty"); node->action = copy_string_field(L, self, 2, "action"); node->salt = copy_string_field(L, self, 2, "salt"); node->pass_index = setup_pass(L, self, 2, node); lua_getfield(L, 2, "inputs"); node->inputs = td_build_file_array(L, self, lua_gettop(L), &node->input_count); lua_pop(L, 1); check_input_files(L, self, node); lua_getfield(L, 2, "outputs"); node->outputs = td_build_file_array(L, self, lua_gettop(L), &node->output_count); lua_pop(L, 1); tag_output_files(L, node); lua_getfield(L, 2, "aux_outputs"); node->aux_outputs = td_build_file_array(L, self, lua_gettop(L), &node->aux_output_count); lua_pop(L, 1); lua_getfield(L, 2, "scanner"); if (!lua_isnil(L, -1)) node->scanner = td_check_scanner(L, -1); else node->scanner = NULL; lua_pop(L, 1); lua_getfield(L, 2, "env"); if (!lua_isnil(L, -1)) { int index = 0, count = 0; lua_pushnil(L); while (lua_next(L, -2)) { ++count; lua_pop(L, 1); } node->env_count = count; node->env = td_page_alloc(&self->alloc, sizeof(const char *) * (count)); lua_pushnil(L); while (lua_next(L, -2)) { int top = lua_gettop(L); node->env[index++] = record_env_mapping(self, L, 1, top-1, top); assert(top == lua_gettop(L)); lua_pop(L, 1); } } else { node->env_count = 0; node->env = NULL; } lua_pop(L, 1); node->flags = 0; node->flags |= check_flag(L, 2, "is_precious", TD_NODE_PRECIOUS); node->flags |= check_flag(L, 2, "overwrite_outputs", TD_NODE_OVERWRITE); node->deps = setup_deps(L, self, node, &node->dep_count); setup_file_signers(L, self, node); memset(&node->job, 0, sizeof(node->job)); noderef = (td_noderef*) lua_newuserdata(L, sizeof(td_noderef)); noderef->node = node; luaL_getmetatable(L, TUNDRA_NODEREF_MTNAME); lua_setmetatable(L, -2); td_setup_ancestor_data(self, node); ++self->node_count; td_call_cache_hook(L, &td_node_hook_key, 2, lua_gettop(L)); return 1; }
static void PrintFinalStats(void *cvode_mem) { long int lenrw, leniw ; long int lenrwSPGMR, leniwSPGMR; long int nst, nfe, nsetups, nni, ncfn, netf; long int nli, npe, nps, ncfl, nfeSPGMR; int flag; flag = CVodeGetWorkSpace(cvode_mem, &lenrw, &leniw); check_flag(&flag, "CVodeGetWorkSpace", 1); flag = CVodeGetNumSteps(cvode_mem, &nst); check_flag(&flag, "CVodeGetNumSteps", 1); flag = CVodeGetNumRhsEvals(cvode_mem, &nfe); check_flag(&flag, "CVodeGetNumRhsEvals", 1); flag = CVodeGetNumLinSolvSetups(cvode_mem, &nsetups); check_flag(&flag, "CVodeGetNumLinSolvSetups", 1); flag = CVodeGetNumErrTestFails(cvode_mem, &netf); check_flag(&flag, "CVodeGetNumErrTestFails", 1); flag = CVodeGetNumNonlinSolvIters(cvode_mem, &nni); check_flag(&flag, "CVodeGetNumNonlinSolvIters", 1); flag = CVodeGetNumNonlinSolvConvFails(cvode_mem, &ncfn); check_flag(&flag, "CVodeGetNumNonlinSolvConvFails", 1); flag = CVSpgmrGetWorkSpace(cvode_mem, &lenrwSPGMR, &leniwSPGMR); check_flag(&flag, "CVSpgmrGetWorkSpace", 1); flag = CVSpgmrGetNumLinIters(cvode_mem, &nli); check_flag(&flag, "CVSpgmrGetNumLinIters", 1); flag = CVSpgmrGetNumPrecEvals(cvode_mem, &npe); check_flag(&flag, "CVSpgmrGetNumPrecEvals", 1); flag = CVSpgmrGetNumPrecSolves(cvode_mem, &nps); check_flag(&flag, "CVSpgmrGetNumPrecSolves", 1); flag = CVSpgmrGetNumConvFails(cvode_mem, &ncfl); check_flag(&flag, "CVSpgmrGetNumConvFails", 1); flag = CVSpgmrGetNumRhsEvals(cvode_mem, &nfeSPGMR); check_flag(&flag, "CVSpgmrGetNumRhsEvals", 1); printf("\nFinal Statistics.. \n\n"); printf("lenrw = %5ld leniw = %5ld\n", lenrw, leniw); printf("llrw = %5ld lliw = %5ld\n", lenrwSPGMR, leniwSPGMR); printf("nst = %5ld\n" , nst); printf("nfe = %5ld nfel = %5ld\n" , nfe, nfeSPGMR); printf("nni = %5ld nli = %5ld\n" , nni, nli); printf("nsetups = %5ld netf = %5ld\n" , nsetups, netf); printf("npe = %5ld nps = %5ld\n" , npe, nps); printf("ncfn = %5ld ncfl = %5ld\n\n", ncfn, ncfl); }
int dialoginfo_set(struct sip_msg* msg, char* flag_pv, char* str2) { struct dlg_cell * dlg; str peer_uri= {0, 0}; /* constructed from TO display name and RURI */ struct to_body* from, peer_to_body, FROM, *to; str* ruri; int len =0,ret=-1; char flag= DLG_PUB_AB; static char buf[256]; int buf_len= 255; str flag_str; char caller_buf[256], callee_buf[256]; pv_value_t tok; peer_to_body.param_lst = FROM.param_lst = NULL; if (msg->REQ_METHOD != METHOD_INVITE) return 1; if(dlg_api.create_dlg(msg,0)< 0) { LM_ERR("Failed to create dialog\n"); return -1; } dlg = dlg_api.get_dlg(); LM_DBG("new INVITE dialog created: from=%.*s\n", dlg->from_uri.len, dlg->from_uri.s); from = get_from(msg); /* if defined overwrite */ if(caller_spec_param.s) /* if parameter defined */ { memset(&tok, 0, sizeof(pv_value_t)); if(pv_get_spec_value(msg, &caller_spec, &tok) < 0) /* if value set */ { LM_ERR("Failed to get caller value\n"); return -1; } if(tok.flags&PV_VAL_STR) { str caller_str; if(tok.rs.len + CRLF_LEN > buf_len) { LM_ERR("Buffer overflow"); return -1; } trim(&tok.rs); memcpy(caller_buf, tok.rs.s, tok.rs.len); len = tok.rs.len; if(strncmp(tok.rs.s+len-CRLF_LEN, CRLF, CRLF_LEN)) { memcpy(caller_buf + len, CRLF, CRLF_LEN); len+= CRLF_LEN; } parse_to(caller_buf, caller_buf+len , &FROM); if(FROM.error != PARSE_OK) { LM_ERR("Failed to parse caller specification - not a valid uri\n"); goto end; } from = &FROM; caller_str.s = caller_buf; caller_str.len = len; LM_DBG("caller: %*s- len= %d\n", len, caller_buf, len); /* store caller in a dlg variable */ if(dlg_api.store_dlg_value(dlg, &entity_dlg_var, &caller_str)< 0) { LM_ERR("Failed to store dialog ruri\n"); goto end; } } } peer_uri.s = callee_buf; if(callee_spec_param.s) { memset(&tok, 0, sizeof(pv_value_t)); if(pv_get_spec_value(msg, &callee_spec, &tok) < 0) { LM_ERR("Failed to get callee value\n"); goto end; } if(tok.flags&PV_VAL_STR) { if(tok.rs.len + CRLF_LEN > buf_len) { LM_ERR("Buffer overflow"); goto end; } trim(&tok.rs); memcpy(peer_uri.s, tok.rs.s, tok.rs.len); len = tok.rs.len; if(strncmp(tok.rs.s+len-CRLF_LEN, CRLF, CRLF_LEN)) { memcpy(peer_uri.s + len, CRLF, CRLF_LEN); len+= CRLF_LEN; } peer_uri.len = len; } else goto default_callee; } else { default_callee: ruri = GET_RURI(msg); to = get_to(msg); len= to->display.len + 2 + ruri->len + CRLF_LEN; if(len > buf_len) { LM_ERR("Buffer overflow\n"); goto end; } len = 0; if(to->display.len && to->display.s) { memcpy(peer_uri.s, to->display.s, to->display.len); peer_uri.s[to->display.len]='<'; len = to->display.len + 1; } memcpy(peer_uri.s + len, ruri->s, ruri->len); len+= ruri->len; if(to->display.len) { peer_uri.s[len++]='>'; } memcpy(peer_uri.s + len, CRLF, CRLF_LEN); len+= CRLF_LEN; peer_uri.len = len; } LM_DBG("Peer uri = %.*s\n", peer_uri.len, peer_uri.s); parse_to(peer_uri.s, peer_uri.s+peer_uri.len, &peer_to_body); if(peer_to_body.error != PARSE_OK) { LM_ERR("Failed to peer uri [%.*s]\n", peer_uri.len, peer_uri.s); goto end; } /* store peer uri in dialog structure */ if(dlg_api.store_dlg_value(dlg, &peer_dlg_var, &peer_uri)< 0) { LM_ERR("Failed to store dialog ruri\n"); goto end; } /* store flag, if defined */ if(flag_pv) { if(pv_printf(msg, (pv_elem_t*)flag_pv, buf, &buf_len)<0) { LM_ERR("cannot print the format\n"); goto end; } if(!check_flag(buf, buf_len)) { LM_ERR("Wrong value for flag\n"); goto end; } flag = buf[0]; flag_str.s = buf; flag_str.len = buf_len; if(dlg_api.store_dlg_value(dlg, &flag_dlg_var, &flag_str)< 0) { LM_ERR("Failed to store dialog ruri\n"); goto end; } } /* register dialog callbacks which triggers sending PUBLISH */ if (dlg_api.register_dlgcb(dlg, DLGCB_FAILED| DLGCB_CONFIRMED | DLGCB_TERMINATED | DLGCB_EXPIRED | DLGCB_RESPONSE_WITHIN | DLGCB_EARLY, __dialog_sendpublish, 0, 0) != 0) { LM_ERR("cannot register callback for interesting dialog types\n"); goto end; } #ifdef PUA_DIALOGINFO_DEBUG /* dialog callback testing (registered last to be executed first) */ if (dlg_api.register_dlgcb(dlg, DLGCB_FAILED| DLGCB_CONFIRMED | DLGCB_REQ_WITHIN | DLGCB_TERMINATED | DLGCB_EXPIRED | DLGCB_EARLY | DLGCB_RESPONSE_FWDED | DLGCB_RESPONSE_WITHIN | DLGCB_MI_CONTEXT | DLGCB_DESTROY, __dialog_cbtest, NULL, NULL) != 0) { LM_ERR("cannot register callback for all dialog types\n"); goto end; } #endif if(publish_on_trying) { if(flag == DLG_PUB_A || flag == DLG_PUB_AB) dialog_publish("trying", from, &peer_to_body, &(dlg->callid), 1, DEFAULT_CREATED_LIFETIME, 0, 0); if(flag == DLG_PUB_B || flag == DLG_PUB_AB) dialog_publish("trying", &peer_to_body, from, &(dlg->callid), 0, DEFAULT_CREATED_LIFETIME, 0, 0); } ret=1; end: if (peer_to_body.param_lst) free_to_params(&peer_to_body); if (FROM.param_lst) free_to_params(&FROM); return ret; }
int main() { realtype t, tout; N_Vector y; void *cvode_mem; int flag, flagr, iout; int rootsfound[2]; y = NULL; cvode_mem = NULL; /* Create serial vector of length NEQ for I.C. */ y = N_VNew_Serial(NEQ); if (check_flag((void *)y, "N_VNew_Serial", 0)) return(1); /* Initialize y */ Ith(y,1) = Y1; Ith(y,2) = Y2; Ith(y,3) = Y3; /* Call CVodeCreate to create the solver memory and specify the * Backward Differentiation Formula and the use of a Newton iteration */ cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON); if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1); /* Call CVodeInit to initialize the integrator memory and specify the * user's right hand side function in y'=f(t,y), the inital time T0, and * the initial dependent variable vector y. */ flag = CVodeInit(cvode_mem, f, T0, y); if (check_flag(&flag, "CVodeInit", 1)) return(1); /* Use private function to compute error weights */ flag = CVodeWFtolerances(cvode_mem, ewt); if (check_flag(&flag, "CVodeSetEwtFn", 1)) return(1); /* Call CVodeRootInit to specify the root function g with 2 components */ flag = CVodeRootInit(cvode_mem, 2, g); if (check_flag(&flag, "CVodeRootInit", 1)) return(1); /* Call CVDense to specify the CVDENSE dense linear solver */ flag = CVDense(cvode_mem, NEQ); if (check_flag(&flag, "CVDense", 1)) return(1); /* Set the Jacobian routine to Jac (user-supplied) */ flag = CVDlsSetDenseJacFn(cvode_mem, Jac); if (check_flag(&flag, "CVDlsSetDenseJacFn", 1)) return(1); /* In loop, call CVode, print results, and test for error. Break out of loop when NOUT preset output times have been reached. */ printf(" \n3-species kinetics problem\n\n"); iout = 0; tout = T1; while(1) { flag = CVode(cvode_mem, tout, y, &t, CV_NORMAL); PrintOutput(t, Ith(y,1), Ith(y,2), Ith(y,3)); if (flag == CV_ROOT_RETURN) { flagr = CVodeGetRootInfo(cvode_mem, rootsfound); check_flag(&flagr, "CVodeGetRootInfo", 1); PrintRootInfo(rootsfound[0],rootsfound[1]); } if (check_flag(&flag, "CVode", 1)) break; if (flag == CV_SUCCESS) { iout++; tout *= TMULT; } if (iout == NOUT) break; } /* Print some final statistics */ PrintFinalStats(cvode_mem); /* Free y vector */ N_VDestroy_Serial(y); /* Free integrator memory */ CVodeFree(&cvode_mem); return(0); }
int main(int argc, char *argv[]) { int globalstrategy; long int local_N; realtype fnormtol, scsteptol; N_Vector cc, sc, constraints; UserData data; int flag, maxl, maxlrst; int my_pe, npes, npelast = NPEX*NPEY-1; void *kmem; MPI_Comm comm; cc = sc = constraints = NULL; data = NULL; kmem = NULL; /* Get processor number and total number of pe's */ MPI_Init(&argc, &argv); comm = MPI_COMM_WORLD; MPI_Comm_size(comm, &npes); MPI_Comm_rank(comm, &my_pe); if (npes != NPEX*NPEY) { if (my_pe == 0) fprintf(stderr, "\nMPI_ERROR(0); npes = %d is not equal to NPEX*NPEY = %d\n", npes,NPEX*NPEY); MPI_Finalize(); return(1); } /* Allocate memory, and set problem data, initial values, tolerances */ /* Set local vector length */ local_N = NUM_SPECIES*MXSUB*MYSUB; /* Allocate and initialize user data block */ data = AllocUserData(); if (check_flag((void *)data, "AllocUserData", 0, my_pe)) MPI_Abort(comm, 1); InitUserData(my_pe, comm, data); /* Set global strategy flag */ globalstrategy = KIN_NONE; /* Allocate and initialize vectors */ cc = N_VNew_Parallel(comm, local_N, NEQ); if (check_flag((void *)cc, "N_VNew_Parallel", 0, my_pe)) MPI_Abort(comm, 1); sc = N_VNew_Parallel(comm, local_N, NEQ); if (check_flag((void *)sc, "N_VNew_Parallel", 0, my_pe)) MPI_Abort(comm, 1); data->rates = N_VNew_Parallel(comm, local_N, NEQ); if (check_flag((void *)data->rates, "N_VNew_Parallel", 0, my_pe)) MPI_Abort(comm, 1); constraints = N_VNew_Parallel(comm, local_N, NEQ); if (check_flag((void *)constraints, "N_VNew_Parallel", 0, my_pe)) MPI_Abort(comm, 1); N_VConst(ZERO, constraints); SetInitialProfiles(cc, sc); fnormtol=FTOL; scsteptol=STOL; /* Call KINCreate/KINMalloc to initialize KINSOL: nvSpec is the nvSpec pointer used in the parallel version A pointer to KINSOL problem memory is returned and stored in kmem. */ kmem = KINCreate(); if (check_flag((void *)kmem, "KINCreate", 0, my_pe)) MPI_Abort(comm, 1); /* Vector cc passed as template vector. */ flag = KINMalloc(kmem, funcprpr, cc); if (check_flag(&flag, "KINMalloc", 1, my_pe)) MPI_Abort(comm, 1); flag = KINSetNumMaxIters(kmem, 250); if (check_flag(&flag, "KINSetNumMaxIters", 1, my_pe)) MPI_Abort(comm, 1); flag = KINSetFdata(kmem, data); if (check_flag(&flag, "KINSetFdata", 1, my_pe)) MPI_Abort(comm, 1); flag = KINSetConstraints(kmem, constraints); if (check_flag(&flag, "KINSetConstraints", 1, my_pe)) MPI_Abort(comm, 1); flag = KINSetFuncNormTol(kmem, fnormtol); if (check_flag(&flag, "KINSetFuncNormTol", 1, my_pe)) MPI_Abort(comm, 1); flag = KINSetScaledStepTol(kmem, scsteptol); if (check_flag(&flag, "KINSetScaledStepTop", 1, my_pe)) MPI_Abort(comm, 1); /* We no longer need the constraints vector since KINSetConstraints creates a private copy for KINSOL to use. */ N_VDestroy_Parallel(constraints); /* Call KINSpgmr to specify the linear solver KINSPGMR with preconditioner routines Precondbd and PSolvebd, and the pointer to the user data block. */ maxl = 20; maxlrst = 2; flag = KINSpgmr(kmem, maxl); if (check_flag(&flag, "KINSpgmr", 1, my_pe)) MPI_Abort(comm, 1); flag = KINSpilsSetMaxRestarts(kmem, maxlrst); if (check_flag(&flag, "KINSpilsSetMaxRestarts", 1, my_pe)) MPI_Abort(comm, 1); flag = KINSpilsSetPreconditioner(kmem, Precondbd, PSolvebd, data); if (check_flag(&flag, "KINSpilsSetPreconditioner", 1, my_pe)) MPI_Abort(comm, 1); /* Print out the problem size, solution parameters, initial guess. */ if (my_pe == 0) PrintHeader(globalstrategy, maxl, maxlrst, fnormtol, scsteptol); /* Call KINSol and print output concentration profile */ flag = KINSol(kmem, /* KINSol memory block */ cc, /* initial guess on input; solution vector */ globalstrategy, /* global stragegy choice */ sc, /* scaling vector for the variable cc */ sc); /* scaling vector for function values fval */ if (check_flag(&flag, "KINSol", 1, my_pe)) MPI_Abort(comm, 1); if (my_pe == 0) printf("\n\nComputed equilibrium species concentrations:\n"); if (my_pe == 0 || my_pe == npelast) PrintOutput(my_pe, comm, cc); /* Print final statistics and free memory */ if (my_pe == 0) PrintFinalStats(kmem); N_VDestroy_Parallel(cc); N_VDestroy_Parallel(sc); KINFree(&kmem); FreeUserData(data); MPI_Finalize(); return(0); }