int main() { // search_space(); solve(112, true); return 0; }
int main() { while(EOF!=scanf("%d",&N) && 0!=N) solve(); return 0; }
int main() { printf("%d\n", solve()); return 0; }
int maxDamage(vector <int> level, vector <int> damage) { memset(dp,-1,sizeof dp); return solve(level,damage,0,0); }
vector<vector<int>> permute(vector<int>& nums) { if (nums.size() <= 1) return {nums}; solve(0, nums); return permutations; }
int main( int argc, char *argv[] ) { if ( (argc == 2) && ( (GF2::console::find_switch(argc,argv,"--help")) || (GF2::console::find_switch(argc,argv,"-h" )) ) ) { std::cout << "[Usage]:\n" << "\t--generate\n" << "\t--generate3D\n" << "\t--formulate\n" << "\t--formulate3D\n" << "\t--solver mosek|bonmin|gurobi\n" << "\t--solver3D mosek|bonmin|gurobi\n" << "\t--merge\n" << "\t--merge3D\n" << "\t--datafit\n" << "\t--corresp\n" //<< "\t--show\n" << std::endl; return EXIT_SUCCESS; } else if ( GF2::console::find_switch(argc,argv,"--segment") || GF2::console::find_switch(argc,argv,"--segment3D") ) { return segment( argc, argv ); } else if ( GF2::console::find_switch(argc,argv,"--generate") || GF2::console::find_switch(argc,argv,"--generate3D") ) { return generate(argc,argv); } else if ( GF2::console::find_switch(argc,argv,"--formulate") || GF2::console::find_switch(argc,argv,"--formulate3D")) { return formulate( argc, argv ); //return GF2::ProblemSetup::formulateCli<GF2::Solver::PrimitiveContainerT, GF2::Solver::PointContainerT>( argc, argv ); } else if ( GF2::console::find_switch(argc,argv,"--solver") || GF2::console::find_switch(argc,argv,"--solver3D") ) // Note: "solver", not "solve" :-S { return solve( argc, argv ); //return GF2::Solver::solve( argc, argv ); } else if ( GF2::console::find_switch(argc,argv,"--datafit") || GF2::console::find_switch(argc,argv,"--datafit3D") ) { return datafit( argc, argv ); //return GF2::Solver::datafit( argc, argv ); } else if ( GF2::console::find_switch(argc,argv,"--merge") || GF2::console::find_switch(argc,argv,"--merge3D") ) { return merge(argc, argv); } else if ( GF2::console::find_switch(argc,argv,"--show") ) { std::cerr << "[" << __func__ << "]: " << "the show option has been moved to a separate executable, please use thatt one" << std::endl; return 1; //return GF2::Solver::show( argc, argv ); } else if ( GF2::console::find_switch(argc,argv,"--subsample") ) { return subsample( argc, argv ); } // else if ( GF2::console::find_switch(argc,argv,"--corresp") || GF2::console::find_switch(argc,argv,"--corresp3D") ) // { // return corresp( argc, argv ); // } std::cerr << "[" << __func__ << "]: " << "unrecognized option" << std::endl; return 1; // --show --dir . --cloud cloud.ply --scale 0.05f --assoc points_primitives.txt --use-tags --no-clusters --prims primitives.bonmin.txt // std::string img_path( "input2.png" ); // pcl::console::parse_argument( argc, argv, "--img", img_path ); // float scale = 0.1f; // pcl::console::parse_argument( argc, argv, "--scale", scale ); // return GF2::Solver::run( img_path, scale, {0, M_PI_2, M_PI}, argc, argv ); }
void SampleSAT::islearn(int datasize, char* outfilename) { int iteration = 0; // iteration counter double drand; // double type random variable int irand; // integer type random variable double lik; // likelihood double stSec1; double stSec2; double stSec3; int step = 1; // length of Markov chain cdsdSec = 0; cdddSec = 0; cntSec = 0; double pF = 0; double adlogmax; double logsum; int admaxidx; double hl_ss; double temp; bool flag; FILE* helFile = fopen(outfilename, "w"); while(iteration < lparams_->maxiter){ iteration++; if(iteration == 1){ for(int j = 0; j < numAtom; j++){ sd[j] = 0; } } stSec1 = timer.time(); ///// sampling routine //// for(int i = 0; i < lparams_->numsample; i++){ drand = sat_->getGrand()*datasize; irand = drand; // get random integers in (0~datasize) for(int j = 0; j < numAtom; j++){ xx[j] = tdata[irand][j]; } // get random one training data (one model) for(int j = 0; j < step; j++){ solve(sat_, xx); } for(int j = 0; j < numAtom; j++){ sbuf[i][j] = xx[j]; } for(int j = 0; j < numAtom; j++){ if(xx[j] == 1){ weight[i] += log(sat_->getTheta(j)); }else{ weight[i] += log(1-sat_->getTheta(j)); } } } normalize(weight, lparams_->numsample); for(int j = 0; j < numAtom; j++){ sd[j] += weight[j]*(xx[j])/(sat_->getTheta(j)) - weight[j]*(1 - xx[j])/(1 - sat_->getTheta(j)); } //sum sample counts cdsdSec += timer.time() - stSec1; /// calc. q(\x|F) from local samples /// for(int j = 0; j < datasize_t; j++){ counts[j] = 0; } stSec3 = timer.time(); for(int i = 0; i < datasize_t; i++){ for(int j = 0; j < numAtom; j++){ if(sdata[i][j] == 1){ q_xF[i] += log(sat_->getRealProb(j)); }else{ q_xF[i] += log(1-sat_->getRealProb(j)); } } } normalize(q_xF, datasize_t); cntSec += timer.time() - stSec3; stSec2 = timer.time(); for(int i = 0; i < datasize; i++){ for(int j = 0; j < numAtom; j++){ dd[j] += (tdata[i][j])/(sat_->getTheta(j)) - (1 - tdata[i][j])/(1 - sat_->getTheta(j)); } } //calc dd for(int j = 0; j < numAtom; j++){ dd[j] /= datasize; } cdddSec += timer.time() - stSec2; for(int j = 0; j < numAtom; j++){ ex[j] = lparams_->ita*(dd[j] - sd[j]); } // calc ex sat_->updateTheta(ex); //update theta pF=0; logsum = 0; adlogmax = -100000; admaxidx = 0; lik=0; // calc approximated p(x|F) from "samples" stSec3 = timer.time(); for(int j = 0; j < datasize_t; j++){ ad[j] = 0; } for(int i = 0; i < datasize_t; i++){ for(int j = 0; j < numAtom; j++){ if(sdata[i][j] == 1){ ad[i] += log(sat_->getTheta(j)); }else{ ad[i] += log(1-sat_->getTheta(j)); } } } normalize(ad,datasize_t); /// calc HL[ad,q_xF] /// hl_ss = 0; for(int i = 0; i < datasize_t; i++){ flag = false; temp = sqrt(ad[i]) - sqrt(q_xF[i]); if(temp > 1.0e-6){ hl_ss += temp*temp; } temp = sqrt(1-ad[i]) - sqrt(1-q_xF[i]); if(temp > 1.0e-6){ hl_ss += temp*temp; } } hl_ss = sqrt(hl_ss); fprintf(helFile,"%11.5e\n",hl_ss); cntSec += timer.time() - stSec3; //lik = calclik(ad); //calcurate log-likelihood //printf("lik=%.15f\n",lik); for(int j = 0; j < numAtom; j++){ sd[j] = 0; dd[j] = 0; } } cout << "calc exp. time(sample) : "; Timer::printTime(cout, cdsdSec); cout << endl; cout << "calc exp. time(data) : "; Timer::printTime(cout, cdddSec); cout << endl; cout << "calc q(x|F) & HD time : "; Timer::printTime(cout, cntSec); cout << endl; }
void timeStepper::timeStep(int &numReads, int &numWrites) { af::timer timeStepTimer = af::timer::start(); PetscPrintf(PETSC_COMM_WORLD, " Time = %f, dt = %f\n\n", time, dt); int numReadsDt, numWritesDt; computeDt(numReadsDt, numWritesDt); /* First take a half step */ PetscPrintf(PETSC_COMM_WORLD, " ---Half step--- \n"); af::timer halfStepTimer = af::timer::start(); currentStep = timeStepperSwitches::HALF_STEP; /* Apply boundary conditions on primOld */ af::timer boundaryTimer = af::timer::start(); boundaries::applyBoundaryConditions(boundaryLeft, boundaryRight, boundaryTop, boundaryBottom, boundaryFront, boundaryBack, *primOld ); setProblemSpecificBCs(numReads,numWrites); double boundaryTime = af::timer::stop(boundaryTimer); int numReadsElemSet, numWritesElemSet; int numReadsComputeFluxes, numWritesComputeFluxes; af::timer elemOldTimer = af::timer::start(); elemOld->set(*primOld, *geomCenter, numReadsElemSet, numWritesElemSet ); double elemOldTime = af::timer::stop(elemOldTimer); af::timer consOldTimer = af::timer::start(); elemOld->computeFluxes(0, *consOld, numReadsComputeFluxes, numWritesComputeFluxes ); numReads = numReadsElemSet + numReadsComputeFluxes; numWrites = numWritesElemSet + numWritesComputeFluxes; double consOldTime = af::timer::stop(consOldTimer); int numReadsExplicitSouces, numWritesExplicitSouces; af::timer explicitSourcesTimer = af::timer::start(); double dX[3]; dX[0] = XCoords->dX1; dX[1] = XCoords->dX2; dX[2] = XCoords->dX3; elemOld->computeExplicitSources(dX, *sourcesExplicit, numReadsExplicitSouces, numWritesExplicitSouces ); numReads += numReadsExplicitSouces; numWrites += numWritesExplicitSouces; double explicitSourcesTime = af::timer::stop(explicitSourcesTimer); int numReadsImplicitSources, numWritesImplicitSources; elemOld->computeImplicitSources(*sourcesImplicitOld, elemOld->tau, numReadsImplicitSources, numWritesImplicitSources ); numReads += numReadsImplicitSources; numWrites += numWritesImplicitSources; af::timer divFluxTimer = af::timer::start(); int numReadsDivFluxes, numWritesDivFluxes; computeDivOfFluxes(*primOld, numReadsDivFluxes, numWritesDivFluxes); numReads += numReadsDivFluxes; numWrites += numWritesDivFluxes; double divFluxTime = af::timer::stop(divFluxTimer); /* Set a guess for prim */ for (int var=0; var < vars::numFluidVars; var++) { prim->vars[var] = primOld->vars[var]; numReads += 1; numWrites += 1; } af::timer inductionEqnTimer = af::timer::start(); cons->vars[vars::B1] = consOld->vars[vars::B1] - 0.5*dt*divFluxes->vars[vars::B1]; cons->vars[vars::B2] = consOld->vars[vars::B2] - 0.5*dt*divFluxes->vars[vars::B2]; cons->vars[vars::B3] = consOld->vars[vars::B3] - 0.5*dt*divFluxes->vars[vars::B3]; prim->vars[vars::B1] = cons->vars[vars::B1]/geomCenter->g; prim->vars[vars::B1].eval(); prim->vars[vars::B2] = cons->vars[vars::B2]/geomCenter->g; prim->vars[vars::B2].eval(); prim->vars[vars::B3] = cons->vars[vars::B3]/geomCenter->g; prim->vars[vars::B3].eval(); double inductionEqnTime = af::timer::stop(inductionEqnTimer); primGuessPlusEps->vars[vars::B1] = prim->vars[vars::B1]; primGuessPlusEps->vars[vars::B2] = prim->vars[vars::B2]; primGuessPlusEps->vars[vars::B3] = prim->vars[vars::B3]; primGuessLineSearchTrial->vars[vars::B1] = prim->vars[vars::B1]; primGuessLineSearchTrial->vars[vars::B2] = prim->vars[vars::B2]; primGuessLineSearchTrial->vars[vars::B3] = prim->vars[vars::B3]; /* Solve dU/dt + div.F - S = 0 to get prim at n+1/2 */ jacobianAssemblyTime = 0.; lineSearchTime = 0.; linearSolverTime = 0.; af::timer solverTimer = af::timer::start(); solve(*prim); double solverTime = af::timer::stop(solverTimer); /* Copy solution to primHalfStepGhosted. WARNING: Right now * primHalfStep->vars[var] points to prim->vars[var]. Might need to do a deep * copy. */ for (int var=0; var < prim->numVars; var++) { primHalfStep->vars[var] = prim->vars[var]; numReads += 1; numWrites += 1; } af::timer halfStepCommTimer = af::timer::start(); primHalfStep->communicate(); double halfStepCommTime = af::timer::stop(halfStepCommTimer); af::timer halfStepDiagTimer = af::timer::start(); halfStepDiagnostics(numReads,numWrites); double halfStepDiagTime = af::timer::stop(halfStepDiagTimer); /* Half step complete */ double halfStepTime = af::timer::stop(halfStepTimer); PetscPrintf(PETSC_COMM_WORLD, "\n"); PetscPrintf(PETSC_COMM_WORLD, " ---Performance report--- \n"); PetscPrintf(PETSC_COMM_WORLD, " Boundary Conditions : %g secs, %g %\n", boundaryTime, boundaryTime/halfStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Setting elemOld : %g secs, %g %\n", elemOldTime, elemOldTime/halfStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Conserved vars Old : %g secs, %g %\n", consOldTime, consOldTime/halfStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Explicit sources : %g secs, %g %\n", explicitSourcesTime, explicitSourcesTime/halfStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Divergence of fluxes: %g secs, %g %\n", divFluxTime, divFluxTime/halfStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Nonlinear solver : %g secs, %g %\n", solverTime, solverTime/halfStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " |- Jacobian assembly: %g secs, %g %\n", jacobianAssemblyTime, jacobianAssemblyTime/halfStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " |- Linear solver : %g secs, %g %\n", linearSolverTime, linearSolverTime/halfStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " |- Linesearch : %g secs, %g %\n", lineSearchTime, lineSearchTime/halfStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Induction equation : %g secs, %g %\n", inductionEqnTime, inductionEqnTime/halfStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Communication : %g secs, %g %\n", halfStepCommTime, halfStepCommTime/halfStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Diagnostics : %g secs, %g %\n", halfStepDiagTime, halfStepDiagTime/halfStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Half step time : %g secs\n\n", halfStepTime ); /* Now take the full step */ PetscPrintf(PETSC_COMM_WORLD, " ---Full step--- \n"); af::timer fullStepTimer = af::timer::start(); currentStep = timeStepperSwitches::FULL_STEP; /* apply boundary conditions on primHalfStep */ boundaryTimer = af::timer::start(); boundaries::applyBoundaryConditions(boundaryLeft, boundaryRight, boundaryTop, boundaryBottom, boundaryFront, boundaryBack, *primHalfStep ); setProblemSpecificBCs(numReads,numWrites); boundaryTime = af::timer::stop(boundaryTimer); af::timer elemHalfStepTimer = af::timer::start(); elemHalfStep->set(*primHalfStep, *geomCenter, numReadsElemSet, numWritesElemSet ); numReads += numReadsElemSet; numWrites += numWritesElemSet; double elemHalfStepTime = af::timer::stop(elemHalfStepTimer); explicitSourcesTimer = af::timer::start(); elemHalfStep->computeExplicitSources(dX, *sourcesExplicit, numReadsExplicitSouces, numWritesExplicitSouces ); numReads += numReadsExplicitSouces; numWrites += numWritesExplicitSouces; explicitSourcesTime = af::timer::stop(explicitSourcesTimer); elemOld->computeImplicitSources(*sourcesImplicitOld, elemHalfStep->tau, numReadsImplicitSources, numWritesImplicitSources ); numReads += numReadsImplicitSources; numWrites += numWritesImplicitSources; divFluxTimer = af::timer::start(); computeDivOfFluxes(*primHalfStep, numReadsDivFluxes, numWritesDivFluxes); numReads += numReadsDivFluxes; numWrites += numWritesDivFluxes; divFluxTime = af::timer::stop(divFluxTimer); inductionEqnTimer = af::timer::start(); cons->vars[vars::B1] = consOld->vars[vars::B1] - dt*divFluxes->vars[vars::B1]; cons->vars[vars::B2] = consOld->vars[vars::B2] - dt*divFluxes->vars[vars::B2]; cons->vars[vars::B3] = consOld->vars[vars::B3] - dt*divFluxes->vars[vars::B3]; prim->vars[vars::B1] = cons->vars[vars::B1]/geomCenter->g; prim->vars[vars::B1].eval(); prim->vars[vars::B2] = cons->vars[vars::B2]/geomCenter->g; prim->vars[vars::B2].eval(); prim->vars[vars::B3] = cons->vars[vars::B3]/geomCenter->g; prim->vars[vars::B3].eval(); inductionEqnTime = af::timer::stop(inductionEqnTimer); primGuessPlusEps->vars[vars::B1] = prim->vars[vars::B1]; primGuessPlusEps->vars[vars::B2] = prim->vars[vars::B2]; primGuessPlusEps->vars[vars::B3] = prim->vars[vars::B3]; primGuessLineSearchTrial->vars[vars::B1] = prim->vars[vars::B1]; primGuessLineSearchTrial->vars[vars::B2] = prim->vars[vars::B2]; primGuessLineSearchTrial->vars[vars::B3] = prim->vars[vars::B3]; /* Solve dU/dt + div.F - S = 0 to get prim at n+1/2. NOTE: prim already has * primHalfStep as a guess */ jacobianAssemblyTime = 0.; lineSearchTime = 0.; linearSolverTime = 0.; solverTimer = af::timer::start(); solve(*prim); solverTime = af::timer::stop(solverTimer); /* Copy solution to primOldGhosted */ for (int var=0; var < prim->numVars; var++) { primOld->vars[var] = prim->vars[var]; numReads += 1; numWrites += 1; } /* Compute diagnostics */ af::timer fullStepCommTimer = af::timer::start(); primOld->communicate(); double fullStepCommTime = af::timer::stop(fullStepCommTimer); time += dt; af::timer fullStepDiagTimer = af::timer::start(); fullStepDiagnostics(numReads,numWrites); double fullStepDiagTime = af::timer::stop(fullStepDiagTimer); /* done */ double fullStepTime = af::timer::stop(fullStepTimer); double timeStepTime = af::timer::stop(timeStepTimer); PetscPrintf(PETSC_COMM_WORLD, "\n"); PetscPrintf(PETSC_COMM_WORLD, " ---Performance report--- \n"); PetscPrintf(PETSC_COMM_WORLD, " Boundary Conditions : %g secs, %g %\n", boundaryTime, boundaryTime/fullStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Setting elemHalfStep: %g secs, %g %\n", elemHalfStepTime, elemHalfStepTime/fullStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Explicit sources : %g secs, %g %\n", explicitSourcesTime, explicitSourcesTime/fullStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Divergence of fluxes: %g secs, %g %\n", divFluxTime, divFluxTime/fullStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Nonlinear solver : %g secs, %g %\n", solverTime, solverTime/fullStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " |- Jacobian assembly: %g secs, %g %\n", jacobianAssemblyTime, jacobianAssemblyTime/fullStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " |- Linear solver : %g secs, %g %\n", linearSolverTime, linearSolverTime/fullStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " |- Linesearch : %g secs, %g %\n", lineSearchTime, lineSearchTime/fullStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Induction equation : %g secs, %g %\n", inductionEqnTime, inductionEqnTime/fullStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Communication : %g secs, %g %\n", fullStepCommTime, fullStepCommTime/fullStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Diagnostics : %g secs, %g %\n", fullStepDiagTime, fullStepDiagTime/fullStepTime * 100 ); PetscPrintf(PETSC_COMM_WORLD, " Full step time : %g secs\n\n", fullStepTime ); PetscPrintf(PETSC_COMM_WORLD, " ---Performance / proc : %g Zone cycles/sec/proc\n", prim->N1Local * prim->N2Local * prim->N3Local / timeStepTime ); PetscPrintf(PETSC_COMM_WORLD, " ---Total Performance : %g Zone cycles/sec\n", N1 * N2 * N3 / timeStepTime ); }
cv::RotatedRect cv::fitEllipse( InputArray _points ) { Mat points = _points.getMat(); int i, n = points.checkVector(2); int depth = points.depth(); CV_Assert( n >= 0 && (depth == CV_32F || depth == CV_32S)); RotatedRect box; if( n < 5 ) CV_Error( CV_StsBadSize, "There should be at least 5 points to fit the ellipse" ); // New fitellipse algorithm, contributed by Dr. Daniel Weiss Point2f c(0,0); double gfp[5], rp[5], t; const double min_eps = 1e-8; bool is_float = depth == CV_32F; const Point* ptsi = points.ptr<Point>(); const Point2f* ptsf = points.ptr<Point2f>(); AutoBuffer<double> _Ad(n*5), _bd(n); double *Ad = _Ad, *bd = _bd; // first fit for parameters A - E Mat A( n, 5, CV_64F, Ad ); Mat b( n, 1, CV_64F, bd ); Mat x( 5, 1, CV_64F, gfp ); for( i = 0; i < n; i++ ) { Point2f p = is_float ? ptsf[i] : Point2f((float)ptsi[i].x, (float)ptsi[i].y); c += p; } c.x /= n; c.y /= n; for( i = 0; i < n; i++ ) { Point2f p = is_float ? ptsf[i] : Point2f((float)ptsi[i].x, (float)ptsi[i].y); p -= c; bd[i] = 10000.0; // 1.0? Ad[i*5] = -(double)p.x * p.x; // A - C signs inverted as proposed by APP Ad[i*5 + 1] = -(double)p.y * p.y; Ad[i*5 + 2] = -(double)p.x * p.y; Ad[i*5 + 3] = p.x; Ad[i*5 + 4] = p.y; } solve(A, b, x, DECOMP_SVD); // now use general-form parameters A - E to find the ellipse center: // differentiate general form wrt x/y to get two equations for cx and cy A = Mat( 2, 2, CV_64F, Ad ); b = Mat( 2, 1, CV_64F, bd ); x = Mat( 2, 1, CV_64F, rp ); Ad[0] = 2 * gfp[0]; Ad[1] = Ad[2] = gfp[2]; Ad[3] = 2 * gfp[1]; bd[0] = gfp[3]; bd[1] = gfp[4]; solve( A, b, x, DECOMP_SVD ); // re-fit for parameters A - C with those center coordinates A = Mat( n, 3, CV_64F, Ad ); b = Mat( n, 1, CV_64F, bd ); x = Mat( 3, 1, CV_64F, gfp ); for( i = 0; i < n; i++ ) { Point2f p = is_float ? ptsf[i] : Point2f((float)ptsi[i].x, (float)ptsi[i].y); p -= c; bd[i] = 1.0; Ad[i * 3] = (p.x - rp[0]) * (p.x - rp[0]); Ad[i * 3 + 1] = (p.y - rp[1]) * (p.y - rp[1]); Ad[i * 3 + 2] = (p.x - rp[0]) * (p.y - rp[1]); } solve(A, b, x, DECOMP_SVD); // store angle and radii rp[4] = -0.5 * atan2(gfp[2], gfp[1] - gfp[0]); // convert from APP angle usage if( fabs(gfp[2]) > min_eps ) t = gfp[2]/sin(-2.0 * rp[4]); else // ellipse is rotated by an integer multiple of pi/2 t = gfp[1] - gfp[0]; rp[2] = fabs(gfp[0] + gfp[1] - t); if( rp[2] > min_eps ) rp[2] = std::sqrt(2.0 / rp[2]); rp[3] = fabs(gfp[0] + gfp[1] + t); if( rp[3] > min_eps ) rp[3] = std::sqrt(2.0 / rp[3]); box.center.x = (float)rp[0] + c.x; box.center.y = (float)rp[1] + c.y; box.size.width = (float)(rp[2]*2); box.size.height = (float)(rp[3]*2); if( box.size.width > box.size.height ) { float tmp; CV_SWAP( box.size.width, box.size.height, tmp ); box.angle = (float)(90 + rp[4]*180/CV_PI); } if( box.angle < -180 ) box.angle += 360; if( box.angle > 360 ) box.angle -= 360; return box; }
int main(){ scanf("%d %d", &N, &M); solve(); return 0; }
void kEpsilon::correct() { if (!turbulence_) { // Re-calculate viscosity mut_ = rho_*Cmu_*sqr(k_)/(epsilon_ + epsilonSmall_); mut_.correctBoundaryConditions(); // Re-calculate thermal diffusivity alphat_ = mut_/Prt_; alphat_.correctBoundaryConditions(); return; } RASModel::correct(); volScalarField divU = fvc::div(phi_/fvc::interpolate(rho_)); if (mesh_.moving()) { divU += fvc::div(mesh_.phi()); } tmp<volTensorField> tgradU = fvc::grad(U_); volScalarField G("RASModel::G", mut_*(tgradU() && dev(twoSymm(tgradU())))); tgradU.clear(); // Update espsilon and G at the wall epsilon_.boundaryField().updateCoeffs(); // Dissipation equation tmp<fvScalarMatrix> epsEqn ( fvm::ddt(rho_, epsilon_) + fvm::div(phi_, epsilon_) - fvm::laplacian(DepsilonEff(), epsilon_) == C1_*G*epsilon_/k_ - fvm::SuSp(((2.0/3.0)*C1_ + C3_)*rho_*divU, epsilon_) - fvm::Sp(C2_*rho_*epsilon_/k_, epsilon_) ); epsEqn().relax(); epsEqn().boundaryManipulate(epsilon_.boundaryField()); solve(epsEqn); bound(epsilon_, epsilon0_); // Turbulent kinetic energy equation tmp<fvScalarMatrix> kEqn ( fvm::ddt(rho_, k_) + fvm::div(phi_, k_) - fvm::laplacian(DkEff(), k_) == G - fvm::SuSp((2.0/3.0)*rho_*divU, k_) - fvm::Sp(rho_*epsilon_/k_, k_) ); kEqn().relax(); solve(kEqn); bound(k_, k0_); // Re-calculate viscosity mut_ = rho_*Cmu_*sqr(k_)/epsilon_; mut_.correctBoundaryConditions(); // Re-calculate thermal diffusivity alphat_ = mut_/Prt_; alphat_.correctBoundaryConditions(); }
int main() { solve(); }
/* entry point */ int main(int argc, char** argv){ solve(); return 0; }
ompl::base::PlannerStatus ompl::tools::Lightning::solve(double time) { ob::PlannerTerminationCondition ptc = ob::timedPlannerTerminationCondition(time); return solve(ptc); }
int depthSum(std::vector<NestedInteger>& V) { return solve(V, 1); }
int main () { int p; scanf("%d", &p); printf("%d\n", solve(p)); return 0; }
int full_solve (hid_t fid, hid_t dataset, hid_t* routeDatasets, hid_t dataspace, hid_t routeDataspace, hid_t datatype, hid_t routeDatatype, int cell_index, const inp_t * input_params, SOURCE_MODE mode, const cell_table_t * cell, const net_t * network, const time_steps_t * ts, int verbose) { double *abundances = NULL; alloc_abundances( network, &abundances ); // Allocate the abundances array; it contains all species. rout_t* routes = NULL; if (( routes = malloc (sizeof (rout_t) * input_params->output.n_output_species * N_OUTPUT_ROUTES)) == NULL) { fprintf (stderr, "astrochem: %s:%d: routes allocation failed.\n", __FILE__, __LINE__); return EXIT_SUCCESS; } double* output_abundances = NULL; if (( output_abundances = malloc (sizeof (double) * input_params->output.n_output_species )) == NULL) { fprintf (stderr, "astrochem: %s:%d: array allocation failed.\n", __FILE__, __LINE__); return EXIT_FAILURE; } #ifdef HAVE_OPENMP omp_set_lock(&lock); #endif // Create the memory dataspace, selecting all output abundances hsize_t size = input_params->output.n_output_species; hid_t memDataspace = H5Screate_simple(1, &size, NULL); // Create the file dataspace, and prepare selection of a chunk of the file hid_t fileDataspace = H5Scopy(dataspace); hsize_t count[3]={ 1, 1, input_params->output.n_output_species }; hsize_t routeSize[2] = { input_params->output.n_output_species, N_OUTPUT_ROUTES }; hsize_t routeCount[4]={ 1, 1, input_params->output.n_output_species, N_OUTPUT_ROUTES }; hid_t routeFileDataspace, routeMemDataspace; if (input_params->output.trace_routes) { // Create the route memory dataspace, selecting all output routes routeMemDataspace = H5Screate_simple(2, routeSize, NULL); // Create the route file dataspace, and prepare selection of a chunk of the file routeFileDataspace = H5Scopy(routeDataspace); } #ifdef HAVE_OPENMP omp_unset_lock(&lock); #endif // Initializing abundance #if 0 //Ultra complicated code const species_name_t* species = malloc( input_params->abundances.n_initial_abundances * sizeof(*species)); double *initial_abundances = malloc( input_params->abundances.n_initial_abundances * sizeof(double) ); int i; for( i = 0; i < input_params->abundances.n_initial_abundances ; i++ ) { strcpy( network->species_names[input_params->abundances.initial_abundances[i].species_idx ] , species[i] ); initial_abundances[i] = input_params->abundances.initial_abundances[i].abundance; } set_initial_abundances( species, 3, initial_abundances, &network, abundances); // Set initial abundances #else // same thing , without using api int i; for( i = 0; i < input_params->abundances.n_initial_abundances ; i++ ) { abundances[ input_params->abundances.initial_abundances[i].species_idx ] = input_params->abundances.initial_abundances[i].abundance; } // Add grain abundances int g, gm, gp; double gabs; g = find_species ("grain", network); gm = find_species ("grain(-)", network); gp = find_species ("grain(+)", network); // Check if grain abundances have already been initialized one way or another gabs=0.0; if(g>=0) gabs += abundances[ g ]; if(gm>=0) gabs += abundances[ gm ]; if(gp>=0) gabs += abundances[ gp ]; if(gabs == 0.0) { // Grains have not been initialized // Check that grains are defined in our network, and if so, set the grain abundance if(g>=0) abundances[ g ] = input_params->phys.grain_abundance; } #endif double min_nh; /* Minimum density */ /* Compute the minimum density to set the absolute tolerance of the solver */ min_nh = cell->nh[0]; if (mode == DYNAMIC) { int i; for (i = 1; i < ts->n_time_steps; i++) { if (cell->nh[i] < min_nh) { min_nh = cell->nh[i]; } } } astrochem_mem_t astrochem_mem; cell_t cell_unik; cell_unik.av = cell->av[0]; cell_unik.nh = cell->nh[0]; cell_unik.tgas = cell->tgas[0]; cell_unik.tdust = cell->tdust[0]; if( solver_init( &cell_unik, network, &input_params->phys, abundances, min_nh, input_params->solver.abs_err, input_params->solver.rel_err, &astrochem_mem ) != EXIT_SUCCESS ) { return EXIT_FAILURE; } else { int i, j; /* Solve the system for each time step. */ for (i = 0; i < ts->n_time_steps; i++) { if (i!=0 && mode == DYNAMIC) { cell_unik.av = cell->av[i]; cell_unik.nh = cell->nh[i]; cell_unik.tgas = cell->tgas[i]; cell_unik.tdust = cell->tdust[i]; if( solve( &astrochem_mem, network, abundances, ts->time_steps[i], &cell_unik, verbose ) != EXIT_SUCCESS ) { return EXIT_FAILURE; } } else { if( solve( &astrochem_mem, network, abundances, ts->time_steps[i], NULL, verbose ) != EXIT_SUCCESS ) { return EXIT_FAILURE; } } /* Fill the array of abundances with the output species abundances. Ignore species that are not in the network. Abundance that are lower than MIN_ABUNDANCES are set to 0. */ for (j = 0; j < input_params->output.n_output_species; j++) { if (mode == STATIC) { output_abundances[j] = (double) NV_Ith_S (astrochem_mem.y, input_params->output.output_species_idx[j]) / cell->nh[0]; } else { output_abundances[j] = (double) NV_Ith_S (astrochem_mem.y, input_params->output.output_species_idx[j]) / cell->nh[i]; } if (output_abundances[j] < MIN_ABUNDANCE) output_abundances[j] = 0.; #ifdef HAVE_OPENMP omp_set_lock(&lock); #endif // Select a chunk of the file hsize_t start[3]={ cell_index, i, 0 }; H5Sselect_hyperslab( fileDataspace, H5S_SELECT_SET, start, NULL, count , NULL ); // Write the chunk H5Dwrite(dataset, datatype, memDataspace, fileDataspace, H5P_DEFAULT, output_abundances ); #ifdef HAVE_OPENMP omp_unset_lock(&lock); #endif } /* Compute the rate of each formation/destruction route for each output specie. */ if (input_params->output.trace_routes) { for (j = 0; j < input_params->output.n_output_species; j++) { int k; int l; for (l = 0; l < N_OUTPUT_ROUTES; l++) { routes[ j*N_OUTPUT_ROUTES + l ].formation.rate = 0; routes[ j*N_OUTPUT_ROUTES + l ].destruction.rate = 0; } for (k = 0; k < network->n_reactions; k++) { /* If the species is a product of the reaction then compute the formation rate. If the rate is greater than the smallest rate in the formation route structure, we add the current reaction number and rate to that structure. */ bool specie_in_products = false; int p; for( p = 0; p < MAX_PRODUCTS; p++ ) { if( network->reactions[k].products[p] == input_params->output.output_species_idx[j]) { specie_in_products = true; break; } } if( specie_in_products ) { r_t formation_route; double min_rate; unsigned int min_rate_index; if (network->reactions[k].reaction_type == 0) { formation_route.rate = astrochem_mem.params.reac_rates[k]; formation_route.rate *= NV_Ith_S (astrochem_mem.y, network->reactions[k].reactants[0]); } else if (network->reactions[k].reaction_type == 23) { formation_route.rate = astrochem_mem.params.reac_rates[k]; } else { formation_route.rate = astrochem_mem.params.reac_rates[k]; int r; for( r = 0; r < MAX_REACTANTS; r++ ) { if( network->reactions[k].reactants[r] != -1 ) { formation_route.rate *= NV_Ith_S (astrochem_mem.y, network->reactions[k].reactants[r]); } } } formation_route.reaction_no = network->reactions[k].reaction_no; min_rate = routes[ j*N_OUTPUT_ROUTES ].formation.rate; min_rate_index = 0; for (l = 1; l < N_OUTPUT_ROUTES; l++) { if (routes[ j*N_OUTPUT_ROUTES + l ].formation.rate < min_rate) { min_rate = routes[ j*N_OUTPUT_ROUTES + l ].formation.rate; min_rate_index = (unsigned int) l; } } if (formation_route.rate > min_rate) { routes[ j*N_OUTPUT_ROUTES + min_rate_index ].formation.rate = formation_route.rate; routes[ j*N_OUTPUT_ROUTES + min_rate_index ].formation.reaction_no = formation_route.reaction_no; } } /* If the species is reactant of the reaction then compute the destruction rate. */ bool species_in_reactants = false; int r; for ( r = 0; r < MAX_REACTANTS; r++ ) { if ( network->reactions[k].reactants[r] == input_params->output.output_species_idx[j]) { species_in_reactants = true; break; } } if( species_in_reactants ) { r_t destruction_route; double min_rate; unsigned int min_rate_index; if (network->reactions[k].reaction_type == 0) { destruction_route.rate = astrochem_mem.params.reac_rates[k]; destruction_route.rate *= NV_Ith_S (astrochem_mem.y, network->reactions[k].reactants[0]); } else if (network->reactions[k].reaction_type == 23) { destruction_route.rate = astrochem_mem.params.reac_rates[k]; } else { destruction_route.rate = astrochem_mem.params.reac_rates[k]; for ( r = 0; r < MAX_REACTANTS; r++ ) { if (network->reactions[k].reactants[r] != -1) { destruction_route.rate *= NV_Ith_S (astrochem_mem.y, network->reactions[k].reactants[r]); } } } destruction_route.reaction_no = network->reactions[k].reaction_no; min_rate = routes[ j*N_OUTPUT_ROUTES ].destruction.rate; min_rate_index = 0; for (l = 1; l < N_OUTPUT_ROUTES; l++) { if (routes[ j*N_OUTPUT_ROUTES + l ].destruction.rate < min_rate) { min_rate = routes[ j*N_OUTPUT_ROUTES + l ].destruction.rate; min_rate_index = (unsigned int) l; } } if (destruction_route.rate > min_rate) { routes[ j*N_OUTPUT_ROUTES + min_rate_index ].destruction.rate = destruction_route.rate; routes[ j*N_OUTPUT_ROUTES + min_rate_index ].destruction.reaction_no = destruction_route.reaction_no; } } } } #ifdef HAVE_OPENMP omp_set_lock(&lock); #endif // Selecting a chunk of the file hsize_t routeStart[4]={ cell_index, i, 0, 0 }; H5Sselect_hyperslab( routeFileDataspace, H5S_SELECT_SET, routeStart, NULL, routeCount , NULL ); int spec_idx; for( spec_idx = 0; spec_idx < input_params->output.n_output_species; spec_idx++ ) { // Writing in each route datasets H5Dwrite( routeDatasets[ spec_idx ], routeDatatype, routeMemDataspace, routeFileDataspace, H5P_DEFAULT, routes ); } #ifdef HAVE_OPENMP omp_unset_lock(&lock); #endif } } } #ifdef HAVE_OPENMP omp_set_lock(&lock); #endif // Cleaning up hdf5 H5Sclose(memDataspace); H5Sclose(fileDataspace); if (input_params->output.trace_routes) { H5Sclose(routeMemDataspace); H5Sclose(routeFileDataspace); } #ifdef HAVE_OPENMP omp_unset_lock(&lock); #endif // Free free( output_abundances ); free( routes ); free_abundances( abundances ); solver_close( &astrochem_mem ); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createTime.H" #include "createMesh.H" #include "createFields.H" #include "initContinuityErrs.H" // create cfdemCloud #include "readGravitationalAcceleration.H" cfdemCloud particleCloud(mesh); #include "checkModelType.H" // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< "\nStarting time loop\n" << endl; while (runTime.loop()) { Info<< "Time = " << runTime.timeName() << nl << endl; #include "readPISOControls.H" #include "CourantNo.H" // do particle stuff Info << "- evolve()" << endl; particleCloud.evolve(voidfraction,Us,U); Ksl.internalField() = particleCloud.momCoupleM(0).impMomSource(); Ksl.correctBoundaryConditions(); #include "solverDebugInfo.H" // get scalar source from DEM particleCloud.forceM(1).manipulateScalarField(Tsource); Tsource.correctBoundaryConditions(); // solve scalar transport equation phi = fvc::interpolate(U*voidfraction) & mesh.Sf(); solve ( fvm::ddt(voidfraction,T) + fvm::div(phi, T) - fvm::laplacian(DT*voidfraction, T) == Tsource ); // Pressure-velocity PISO corrector { // Momentum predictor fvVectorMatrix UEqn ( fvm::ddt(voidfraction,U) + fvm::div(phi, U) + turbulence->divDevReff(U) == - fvm::Sp(Ksl/rho,U) ); UEqn.relax(); if (momentumPredictor) { //solve UEqn if (modelType=="B") solve(UEqn == - fvc::grad(p) + Ksl/rho*Us); else solve(UEqn == - voidfraction*fvc::grad(p) + Ksl/rho*Us); } // --- PISO loop //for (int corr=0; corr<nCorr; corr++) int nCorrSoph = nCorr + 5 * pow((1-particleCloud.dataExchangeM().timeStepFraction()),1); for (int corr=0; corr<nCorrSoph; corr++) { volScalarField rUA = 1.0/UEqn.A(); surfaceScalarField rUAf("(1|A(U))", fvc::interpolate(rUA)); U = rUA*UEqn.H(); phi = fvc::interpolate(U*voidfraction) & mesh.Sf(); //+ fvc::ddtPhiCorr(rUA, U, phi) surfaceScalarField phiS(fvc::interpolate(Us*voidfraction) & mesh.Sf()); surfaceScalarField phiGes = phi + rUAf*(fvc::interpolate(Ksl/rho) * phiS); volScalarField rUAvoidfraction("(voidfraction2|A(U))",rUA*voidfraction); if (modelType=="A") rUAvoidfraction = volScalarField("(voidfraction2|A(U))",rUA*voidfraction*voidfraction); // Non-orthogonal pressure corrector loop for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++) { // Pressure corrector fvScalarMatrix pEqn ( fvm::laplacian(rUAvoidfraction, p) == fvc::div(phiGes) + fvc::ddt(voidfraction) ); pEqn.setReference(pRefCell, pRefValue); if ( corr == nCorr-1 && nonOrth == nNonOrthCorr ) { pEqn.solve(mesh.solver("pFinal")); } else { pEqn.solve(); } if (nonOrth == nNonOrthCorr) { phiGes -= pEqn.flux(); } } // end non-orthogonal corrector loop #include "continuityErrs.H" if (modelType=="B") U -= rUA*fvc::grad(p) - Ksl/rho*Us*rUA; else U -= voidfraction*rUA*fvc::grad(p) - Ksl/rho*Us*rUA; U.correctBoundaryConditions(); } // end piso loop } turbulence->correct(); runTime.write(); Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << nl << endl; } Info<< "End\n" << endl; return 0; }
int main() { solve(); return 0; }
size_t FieldStatic::solveRows() { size_t maxIterationsCount = 0; auto solveStart = picosecFromStart(); if (transposed) { if (algo::ftr().Balancing()) { --balancingCounter; if (balancingCounter == 0) { shouldSendWeights = true; balancingCounter = (int)algo::ftr().TransposeBalanceIterationsInterval(); } } resetCalculatingRows(); bool first = true; if (myCoord == 0) { balanceBundleSize(); } bool solving = true; while (solving) { size_t fromFirstPassRow = 0; size_t fromSecondPassRow = 0; while (fromSecondPassRow < height) { size_t nextSecondPassRow = 0; if (fromSecondPassRow < height && fromFirstPassRow > fromSecondPassRow) { nextSecondPassRow = secondPasses(fromSecondPassRow, first, true); } size_t nextFirstPassRow = 0; if (fromFirstPassRow < height) { nextFirstPassRow = firstPasses(fromFirstPassRow, first, true); } if (nextFirstPassRow == 0 && nextSecondPassRow == 0) { if (fromFirstPassRow < height) { nextFirstPassRow = firstPasses(fromFirstPassRow, first, false); } else { nextSecondPassRow = secondPasses(fromSecondPassRow, first, false); } } if (nextFirstPassRow > 0) { if (nextFirstPassRow == height * 2) { solving = false; break; } fromFirstPassRow = nextFirstPassRow; } if (nextSecondPassRow > 0) { fromSecondPassRow = nextSecondPassRow; } } if (solving == false) { break; } first = false; std::swap(nextCalculatingRows, calculatingRows); ++maxIterationsCount; if (maxIterationsCount >= MAX_ITTERATIONS_COUNT) { break; } if (leftN == NOBODY) { solving = false; for (size_t row = 0; row < height; ++row) { if (calculatingRows[row]) { solving = true; break; } } if (solving == false) { sendDoneAsFirstPass(); } } } } else { if (shouldBalanceNext) { balance(); shouldBalanceNext = false; } size_t firstRealRow = (topN == NOBODY ? 0 : 1); size_t lastRealRow = height - firstRealRow - (bottomN ? 0 : 1); for (size_t row = 0; row < height; ++row) { fillFactors(row, true); double delta = solve(row, true); size_t iterationsCount = 1; auto startTime = picosecFromStart(); while (delta > epsilon) { fillFactors(row, false); delta = solve(row, false); ++iterationsCount; if (iterationsCount > MAX_ITTERATIONS_COUNT) { break; } } maxIterationsCount = std::max(maxIterationsCount, iterationsCount); if (firstRealRow <= row && row <= lastRealRow) { weights[mySY + row - firstRealRow] = weights[mySY + row - firstRealRow] * algo::ftr().TransposeBalanceFactor() + iterationsCount * (1.0 - algo::ftr().TransposeBalanceTimeFactor()) + (picosecFromStart() - startTime) * 1e-12 * algo::ftr().TransposeBalanceTimeFactor(); } } } if (transposed) { syncPartTime += picosecFromStart() - solveStart; } else { parallelPartTime += picosecFromStart() - solveStart; } return maxIterationsCount; }
int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createTime.H" #include "createDynamicFvMesh.H" pimpleControl pimple(mesh); #include "createFields.H" #include "readTimeControls.H" bool checkMeshCourantNo = readBool(pimple.dict().lookup("checkMeshCourantNo")); // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // #include "initContinuityErrs.H" #include "readCourantType.H" dimensionedScalar v_zero("v_zero", dimVolume/dimTime, 0.0); Info<< "\nStarting time loop\n" << endl; #include "createSurfaceFields.H" #include "markBadQualityCells.H" while (runTime.run()) { #include "acousticCourantNo.H" #include "compressibleCourantNo.H" #include "readTimeControls.H" #include "setDeltaT.H" runTime++; psi.oldTime(); rho.oldTime(); p.oldTime(); U.oldTime(); h.oldTime(); Info<< "Time = " << runTime.timeName() << nl << endl; // --- Move mesh and update fluxes { // Do any mesh changes mesh.update(); if (mesh.changing()) { if (runTime.timeIndex() > 1) { surfaceScalarField amNew = min(min(phiv_pos - fvc::meshPhi(rho,U) - cSf_pos, phiv_neg - fvc::meshPhi(rho,U) - cSf_neg), v_zero); phiNeg += kappa*(amNew - am)*p_neg*psi_neg; phiPos += (1.0 - kappa)*(amNew - am)*p_neg*psi_neg; } else { phiNeg -= fvc::meshPhi(rho,U) * fvc::interpolate(rho); } phi = phiPos + phiNeg; if (checkMeshCourantNo) { #include "meshCourantNo.H" } #include "markBadQualityCells.H" } } // --- Solve density solve ( fvm::ddt(rho) + fvc::div(phi) ); Info<< "rho max/min : " << max(rho).value() << " " << min(rho).value() << endl; // --- Solve momentum #include "UEqn.H" // --- Solve energy #include "hEqn.H" // --- Solve pressure (PISO) { while (pimple.correct()) { #include "pEqnDyM.H" } #include "updateKappa.H" } // --- Solve turbulence turbulence->correct(); Ek = 0.5*magSqr(U); EkChange = fvc::ddt(rho,Ek) + fvc::div(phiPos,Ek) + fvc::div(phiNeg,Ek); dpdt = fvc::ddt(p) - fvc::div(fvc::meshPhi(rho,U), p); runTime.write(); Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << nl << endl; } Info<< "End\n" << endl; return 0; }
int main(int argc, char *argv[]) { #include "setRootCase.H" #include "createTime.H" #include "createMesh.H" #include "createFields.H" #include "initContinuityErrs.H" // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info<< nl << "Starting time loop" << endl; while (runTime.loop()) { #include "readPISOControls.H" #include "readBPISOControls.H" Info<< "Time = " << runTime.timeName() << nl << endl; #include "CourantNo.H" { fvVectorMatrix UEqn ( fvm::ddt(U) + fvm::div(phi, U) - fvc::div(phiB, 2.0*DBU*B) - fvm::laplacian(nu, U) + fvc::grad(DBU*magSqr(B)) ); solve(UEqn == -fvc::grad(p)); // --- PISO loop for (int corr=0; corr<nCorr; corr++) { volScalarField rUA = 1.0/UEqn.A(); U = rUA*UEqn.H(); phi = (fvc::interpolate(U) & mesh.Sf()) + fvc::ddtPhiCorr(rUA, U, phi); for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++) { fvScalarMatrix pEqn ( fvm::laplacian(rUA, p) == fvc::div(phi) ); pEqn.setReference(pRefCell, pRefValue); pEqn.solve(); if (nonOrth == nNonOrthCorr) { phi -= pEqn.flux(); } } #include "continuityErrs.H" U -= rUA*fvc::grad(p); U.correctBoundaryConditions(); } } // --- B-PISO loop for (int Bcorr=0; Bcorr<nBcorr; Bcorr++) { fvVectorMatrix BEqn ( fvm::ddt(B) + fvm::div(phi, B) - fvc::div(phiB, U) - fvm::laplacian(DB, B) ); BEqn.solve(); volScalarField rBA = 1.0/BEqn.A(); phiB = (fvc::interpolate(B) & mesh.Sf()) + fvc::ddtPhiCorr(rBA, B, phiB); fvScalarMatrix pBEqn ( fvm::laplacian(rBA, pB) == fvc::div(phiB) ); pBEqn.solve(); phiB -= pBEqn.flux(); #include "magneticFieldErr.H" } runTime.write(); } Info<< "End\n" << endl; return 0; }
void solveSudoku(vector<vector<char>>& board) { solve(board); }
int main() { char * place_name; printf("\n---Enter the name of the result file.---"); scanf("\n%s", filename); fpr = fopen(filename, "w"); readin(); #ifdef WSPN printf("---Enter the initial value.\n"); scanf("%e", &mu); netobj = head_net; i = 1; while (i <= 6) { net_name = strdup( netobj->comment->next->line); if (strcmp(net_name, "tiny/firstsubnet") == 0) change_trate("T14", mu); else change_trate("T13", mu); write_file(net_name); put_file(); solve(net_name); if (strcmp(net_name, "tiny/firstsubnet") == 0) { fprintf(fpr, "\n %d First: %f", i, mu); p1 = value_pmmean("P1"); p13 = value_pmmean("P13"); mu1 = value_trate("T1"); mu = (p1 * mu1) / (1 - p13); } else { fprintf(fpr, "\n %d Second: %f", i, mu); p2 = value_pmmean("P2"); p16 = value_pmmean("P16"); mu2 = value_trate("T2"); mu = (p2 * mu2) / (1 - p16); } if (netobj == head_net) netobj = head_net->next; else netobj = head_net; i++; } #else net_name = strdup( netobj->comment->next->line); solve( net_name ); place_name = "P1"; printf( "info for %s, pmmean = %f, P(0) = %f, P(1) = %f, P(2) = %f, P(3) = %f, P(4) = %f\n", place_name, value_pmmean( place_name ), value_prob( place_name, 0 ), value_prob( place_name, 1 ), value_prob( place_name, 2 ), value_prob( place_name, 3 ), value_prob( place_name, 4 ) ); place_name = "P7"; printf( "info for %s, pmmean = %f, P(0) = %f, P(1) = %f, P(2) = %f, P(3) = %f, P(4) = %f\n", place_name, value_pmmean( place_name ), value_prob( place_name, 0 ), value_prob( place_name, 1 ), value_prob( place_name, 2 ), value_prob( place_name, 3 ), value_prob( place_name, 4 ) ); place_name = "P11"; printf( "info for %s, pmmean = %f, P(0) = %f, P(1) = %f, P(2) = %f, P(3) = %f, P(4) = %f\n", place_name, value_pmmean( place_name ), value_prob( place_name, 0 ), value_prob( place_name, 1 ), value_prob( place_name, 2 ), value_prob( place_name, 3 ), value_prob( place_name, 4 ) ); #endif (void) fclose(fpr); printf("\n\n"); return 0; }
void CPoissonExt::poissonExtend_cuda(cv::Mat &dst,int size) { cv::Mat gx=Mat::zeros(h+2*ex,w+2*ex,CV_32FC4); cv::Mat gy=Mat::zeros(h+2*ex,w+2*ex,CV_32FC4); #pragma omp parallel for for(int y=0;y<h+ex*2;y++) for (int x=0;x<w+ex*2;x++) { if(type[y*(w+2*ex)+x]>1) { Vec4f BGRA0; Vec4f BGRA1; BGRA1=dst.at<Vec4b>(y,x); if(x>0) { if(type[y*(w+2*ex)+x-1]>1) { BGRA0=dst.at<Vec4b>(y,x-1); if(BGRA0!=Vec4f(255,0,255,0)&&BGRA1!=Vec4f(255,0,255,0)) gx.at<Vec4f>(y,x)=BGRA1-BGRA0; } } if(y>0) { if(type[(y-1)*(w+2*ex)+x]>1) { BGRA0=dst.at<Vec4b>(y-1,x); if(BGRA0!=Vec4f(255,0,255)&&BGRA1!=Vec4f(255,0,255)) gy.at<Vec4f>(y,x)=BGRA1-BGRA0; } } } } //matrix cusp::csr_matrix<int,float,cusp::host_memory> A(size,size,5*size-w*2-h*2); cusp::array1d<float, cusp::host_memory> X0(A.num_rows, 0); cusp::array1d<float, cusp::host_memory> B0(A.num_rows, 0); cusp::array1d<float, cusp::host_memory> X1(A.num_rows, 0); cusp::array1d<float, cusp::host_memory> B1(A.num_rows, 0); cusp::array1d<float, cusp::host_memory> X2(A.num_rows, 0); cusp::array1d<float, cusp::host_memory> B2(A.num_rows, 0); // cusp::array1d<float, cusp::host_memory> X3(A.num_rows, 0); // cusp::array1d<float, cusp::host_memory> B3(A.num_rows, 0); int nNonZeros=0; A.row_offsets[0]=0; Vec4f BGRA; for(int y=0;y<h+ex*2;y++) for (int x=0;x<w+ex*2;x++) { float a[5]; a[0]=a[1]=a[2]=a[3]=a[4]=0.0f; int ii=y*(w+2*ex)+x; switch(type[ii]) { case 0://inside break; case 1://boundary a[2]+=1.0f; BGRA=dst.at<Vec4b>(y,x); B0[index[ii]]+=BGRA[0]; B1[index[ii]]+=BGRA[1]; B2[index[ii]]+=BGRA[2]; // B3[index[ii]]+=BGRA[3]; case 2://outside if(y-1>=0&&type[ii-(w+2*ex)]>0) { a[2]+=1.0f; a[0]-=1.0f; BGRA=gy.at<Vec4f>(y,x); B0[index[ii]]+=BGRA[0]; B1[index[ii]]+=BGRA[1]; B2[index[ii]]+=BGRA[2]; // B3[index[ii]]+=BGRA[3]; } if(x-1>=0&&type[ii-1]>0) { a[2]+=1.0f; a[1]-=1.0f; BGRA=gx.at<Vec4f>(y,x); B0[index[ii]]+=BGRA[0]; B1[index[ii]]+=BGRA[1]; B2[index[ii]]+=BGRA[2]; // B3[index[ii]]+=BGRA[3]; } if(x+1<w+2*ex&&type[ii+1]>0) { a[2]+=1.0f; a[3]-=1.0f; BGRA=gx.at<Vec4f>(y,x+1); B0[index[ii]]-=BGRA[0]; B1[index[ii]]-=BGRA[1]; B2[index[ii]]-=BGRA[2]; // B3[index[ii]]+=BGRA[3]; } if(y+1<h+2*ex&&type[ii+(w+2*ex)]>0) { a[2]+=1.0f; a[4]-=1.0f; BGRA=gy.at<Vec4f>(y+1,x); B0[index[ii]]-=BGRA[0]; B1[index[ii]]-=BGRA[1]; B2[index[ii]]-=BGRA[2]; // B3[index[ii]]+=BGRA[3]; } //put into A if(a[0]!=0) { A.values[nNonZeros]=a[0]; A.column_indices[nNonZeros]=index[ii-(w+2*ex)]; nNonZeros++; } if(a[1]!=0) { A.values[nNonZeros]=a[1]; A.column_indices[nNonZeros]=index[ii-1]; nNonZeros++; } if(a[2]!=0) { A.values[nNonZeros]=a[2]; A.column_indices[nNonZeros]=index[ii]; nNonZeros++; } if(a[3]!=0) { A.values[nNonZeros]=a[3]; A.column_indices[nNonZeros]=index[ii+1]; nNonZeros++; } if(a[4]!=0) { A.values[nNonZeros]=a[4]; A.column_indices[nNonZeros]=index[ii+(w+2*ex)]; nNonZeros++; } A.row_offsets[index[ii]+1]=nNonZeros; break; } } //SOLVER; solve(A,B0,X0); solve(A,B1,X1); solve(A,B2,X2); // solve(A,B3,X3); //paste #pragma omp parallel for for(int y=0;y<h+ex*2;y++) for (int x=0;x<w+ex*2;x++) { int ii=y*(w+2*ex)+x; if(type[ii]>0) { int B=MIN(MAX(X0[index[ii]],0),255); int G=MIN(MAX(X1[index[ii]],0),255); int R=MIN(MAX(X2[index[ii]],0),255); int A=0; dst.at<Vec4b>(y,x)=Vec4b(B,G,R,A); } } }
int run() { while ( init(), input() ) { output(solve()); } return 0; }
int main() { int T; scanf( "%d", &T ); while( T-- ) solve(); return 0; }
void realizableKE_Veh::correct() { RASModel::correct(); if (!turbulence_) { return; } const volTensorField gradU(fvc::grad(U_)); const volScalarField S2(2*magSqr(dev(symm(gradU)))); const volScalarField magS(sqrt(S2)); const volScalarField eta(magS*k_/epsilon_); tmp<volScalarField> C1 = max(eta/(scalar(5) + eta), scalar(0.43)); volScalarField G("RASModel::G", nut_*S2); //Estimating source terms for vehicle canopy volVectorField Fi = 0.5*Cfcar_*VAD_*mag(U_-Ucar_)*(U_-Ucar_); volScalarField Fk = (U_-Ucar_)&Fi; volScalarField Fepsilon = epsilon_*sqrt(k_)*Cecar_/L_; // Update epsilon and G at the wall epsilon_.boundaryField().updateCoeffs(); // Dissipation equation tmp<fvScalarMatrix> epsEqn ( fvm::ddt(epsilon_) + fvm::div(phi_, epsilon_) - fvm::Sp(fvc::div(phi_), epsilon_) - fvm::laplacian(DepsilonEff(), epsilon_) == Fepsilon + C1*magS*epsilon_ - fvm::Sp ( C2_*epsilon_/(k_ + sqrt(nu()*epsilon_)), epsilon_ ) ); epsEqn().relax(); epsEqn().boundaryManipulate(epsilon_.boundaryField()); solve(epsEqn); bound(epsilon_, epsilonMin_); // Turbulent kinetic energy equation tmp<fvScalarMatrix> kEqn ( fvm::ddt(k_) + fvm::div(phi_, k_) - fvm::Sp(fvc::div(phi_), k_) - fvm::laplacian(DkEff(), k_) == Fk + G - fvm::Sp(epsilon_/k_, k_) ); kEqn().relax(); solve(kEqn); bound(k_, kMin_); // Re-calculate viscosity nut_ = rCmu(gradU, S2, magS)*sqr(k_)/epsilon_; nut_.correctBoundaryConditions(); }
int main() { init(); cal(); solve(); return 0; }
V & tsv (V &v, const M &m, C) { return v = solve (m, v, C ()); }