Real CPICashFlow::amount() const { Real I0 = baseFixing(); Real I1; // what interpolation do we use? Index / flat / linear if (interpolation() == CPI::AsIndex ) { I1 = index()->fixing(fixingDate()); } else { // work out what it should be //std::cout << fixingDate() << " and " << frequency() << std::endl; //std::pair<Date,Date> dd = inflationPeriod(fixingDate(), frequency()); //std::cout << fixingDate() << " and " << dd.first << " " << dd.second << std::endl; // work out what it should be std::pair<Date,Date> dd = inflationPeriod(fixingDate(), frequency()); Real indexStart = index()->fixing(dd.first); if (interpolation() == CPI::Linear) { Real indexEnd = index()->fixing(dd.second+Period(1,Days)); // linear interpolation //std::cout << indexStart << " and " << indexEnd << std::endl; I1 = indexStart + (indexEnd - indexStart) * (fixingDate() - dd.first) / ( (dd.second+Period(1,Days)) - dd.first); // can't get to next period's value within current period } else { // no interpolation, i.e. flat = constant, so use start-of-period value I1 = indexStart; } } if (growthOnly()) return notional() * (I1 / I0 - 1.0); else return notional() * (I1 / I0); }
SwaptionVolCube1::Cube::Cube( const std::vector<Date>& optionDates, const std::vector<Period>& swapTenors, const std::vector<Time>& optionTimes, const std::vector<Time>& swapLengths, Size nLayers, bool extrapolation) : optionTimes_(optionTimes), swapLengths_(swapLengths), optionDates_(optionDates), swapTenors_(swapTenors), nLayers_(nLayers), extrapolation_(extrapolation) { QL_REQUIRE(optionTimes.size()>1,"Cube::Cube(...): optionTimes.size()<2"); QL_REQUIRE(swapLengths.size()>1,"Cube::Cube(...): swapLengths.size()<2"); QL_REQUIRE(optionTimes.size()==optionDates.size(), "Cube::Cube(...): optionTimes/optionDates mismatch"); QL_REQUIRE(swapTenors.size()==swapLengths.size(), "Cube::Cube(...): swapTenors/swapLengths mismatch"); std::vector<Matrix> points(nLayers_, Matrix(optionTimes_.size(), swapLengths_.size(), 0.0)); for (Size k=0;k<nLayers_;k++) { transposedPoints_.push_back(transpose(points[k])); boost::shared_ptr<Interpolation2D> interpolation (new BilinearInterpolation (optionTimes_.begin(), optionTimes_.end(), swapLengths_.begin(), swapLengths_.end(), transposedPoints_[k])); interpolators_.push_back(boost::shared_ptr<Interpolation2D>( new FlatExtrapolator2D(interpolation))); interpolators_[k]->enableExtrapolation(); } setPoints(points); }
///========================================================================================================================================== /// Friend Functions ///========================================================================================================================================== inline const AABB3D Interpolate(const AABB3D& start, const AABB3D& end, float fractionFromStartToEnd){ const Vec3 interpolatedMins = Interpolate(start.mins, end.mins, fractionFromStartToEnd); const Vec3 interpolatedMaxs = Interpolate(start.maxs, end.maxs, fractionFromStartToEnd); AABB3D interpolation(interpolatedMins, interpolatedMaxs); return interpolation; }
void Ploter::plotCorrectedHll(string filename){ ofstream file(filename); string line; int x1, x2; double y1, y2; x1 = 0; y1 = 0; x2 = CARDMAX/STEP-1; y2 = 0; uint64_t hash; uint64_t hash128[2]; vector<double> estimates = makeVector(); int i; vector< vector<double> > tab(CARDMAX/STEP, vector<double>(TESTS)); int ca = 0; for(i = 0; i < TESTS; i ++){ cout << i << endl; Hll hll(14); for(int j = 0; j < CARDMAX; j++){ MurmurHash3_x86_128(&ca, 4, 0, &hash128); ca++; hash = hash128[0]; hll.AddItem64(hash); if(j%STEP == 0){ double count = hll.CountRaw64(); for(int i = 0; i < CARDMAX/STEP-1; i++){ if(estimates[i] <= count && count < estimates[i+1]){ x1 = estimates[i]; y1 = i*STEP; x2 = estimates[i+1]; y2 = (i+1)*STEP; count = interpolation(count, x1, y1, x2, y2); } } //count = interpolation(count, x1, y1, x2, y2); //count = (double)abs(count-j)/j; tab[j/STEP][i]=count; } } } for(int j = 0; j < CARDMAX/STEP; j++){ double sum = 0; for (int k = 0; k < TESTS; k++){ sum= sum + tab[j][k]; } //cout << sum << endl; double median = percentile(tab[j],0.5); double pct01 = percentile(tab[j],0.01); double pct99 = percentile(tab[j],0.99); file << (j*STEP) << "\t" << (double)sum/TESTS << "\t" << (double)median << "\t" << pct01 << "\t" << pct99 << endl; } }
// equations 28 and 30; double IonSpectrumInwards(double r, double E) { double flux, dr; double term1 = 0, term2 = 0; double (*PhiPtr)(double); PhiPtr = &Potential_Phi; dr = Potential_Phi_Inv( E/q + Potential_Phi(r) ); if ( dr < r ) dr = roundf(dr * 10000) / 10000 + 1e-5; term1 = 1/q; term1 *= pow(dr/r,2); term1 *= interpolation(Table->S, dr) / abs(differentiat(*PhiPtr, dr)); term1 /= 1 - pow(fusor->Tc * g(0,dr),2); if ( fusor->a < r ) { // inwards flux outside the cathode if ( dr < r || fusor->b < dr ) { printf("IonSpectrumInwards error: dr < r or b < dr:\n \tr = %E\n \tdr = %E\n \tE = %E\n", r, dr, E); return NAN; } term1 *= g(r,dr); if ( DELTA(E - ParticleEnergy1(r)) ) term2 = pow(fusor->b/r,2) * EdgeIonFlux * f(r); flux = term1 + term2; } else { if ( dr < fusor->a || fusor->b < dr ) { printf("IonSpectrumInwards error: dr < a or b < dr:\n \tr = %E\n \tdr = %E\n \tE = %E\n", r, dr, E); return NAN; } // inwards flux inside the cathode term1 *= g(fusor->a,dr) * exp(fusor->ngas* CrosssecCX(ParticleEnergy2(fusor->a,dr)) * (r - fusor->a)); if ( DELTA(E - ParticleEnergy1(r)) ) { term2 = pow(fusor->b/r,2) * EdgeIonFlux ; term2 *= f(fusor->a) * exp(fusor->ngas* CrosssecCX(ParticleEnergy1(fusor->a)) * (r - fusor->a)); } flux = fusor->Tc * (term1 + term2); } return flux; }
float Octave::getValueAt(float x, float y) { float f_dimension = (float)dimension; int x_i = (int)(f_dimension*x); int y_i = (int)(f_dimension*y); float x_r = x*dimension -(float)x_i; float y_r = y*dimension - (float)y_i; float x0y0 = getValueAt(x_i, y_i); float x1y1 = getValueAt(x_i+1, y_i+1); float x0y1 = getValueAt(x_i, y_i+1); float x1y0 = getValueAt(x_i+1, y_i); return ( (1-x_r)*interpolation(x0y0, x0y1, y_r) + x_r*interpolation(x1y0, x1y1, y_r) + (1-y_r)*interpolation(x0y0, x1y0, x_r) + y_r*interpolation(x0y1, x1y1, x_r) )*0.5; }
void get_interpolation_res(const del_point2d_t& ball) { triangle tr =searchtri(ball); tr.print(); vector<formation> f2(3); for(int i=0;i<3;++i) f2[i] = f[tr.x[i]];// , f[tr.x[1]], f[tr.x[2]] }; formation gg = interpolation(f2,ball); cout << "Result : \n"; gg.print(); }
void SwaptionVolCube1::Cube::updateInterpolators() const { for (Size k=0; k<nLayers_; ++k) { transposedPoints_[k] = transpose(points_[k]); boost::shared_ptr<Interpolation2D> interpolation ( new BilinearInterpolation (optionTimes_.begin(), optionTimes_.end(), swapLengths_.begin(), swapLengths_.end(), transposedPoints_[k])); interpolators_[k] = boost::shared_ptr<Interpolation2D>( new FlatExtrapolator2D(interpolation)); interpolators_[k]->enableExtrapolation(); } }
/* from input buffer to acc */ static void process_intput_buffer(pitch_t pitch) { register int i, len = pitch->step; /* forwards sweep */ interpolation(pitch, pitch->buf+pitch->overlap, pitch->step+pitch->overlap, pitch->tmp, pitch->step, pitch->rate); for (i=0; i<len; i++) pitch->acc[i] = pitch->fade[i]*pitch->tmp[i]; /* backwards sweep */ interpolation(pitch, pitch->buf, pitch->step+pitch->overlap, pitch->tmp, pitch->step, -pitch->rate); for (i=0; i<len; i++) pitch->acc[i] += pitch->fade[pitch->step-i-1]*pitch->tmp[i]; }
void solveProblem(char * filename, int d1, int d2,int B, bool fromPoints) { char * polynomial1, * polynomial2; BivariatePolynomial * Bp1; BivariatePolynomial * Bp2; if(fromPoints == true) { MatrixXd pointsMatrix, pointsMatrix2; Parser::readPoints(pointsMatrix, pointsMatrix2, cin); cout<<"Points 1 :"<<endl; cout<<pointsMatrix<<endl; cout<<"Points 2 :"<<endl; cout<<pointsMatrix2<<endl; ofstream equationsTxt; equationsTxt.open("InterpolationEquations.txt"); Interpolation interpolation(d1, pointsMatrix), interpolation2(d2 , pointsMatrix2); Bp1 = interpolation.find(equationsTxt); Bp2 = interpolation2.find(equationsTxt); if(Bp1 == NULL || Bp2 == NULL) { cout << "Error in interpolation" << endl; exit(0); } equationsTxt.close(); //interpolation logic } else { Parser::readInput(filename, polynomial1, polynomial2); //read d1, d2, p1, p2 fprintf(stdout,"Equations \n------- \n%s\n%s\n ", polynomial1, polynomial2); int systemDegree=0; Bp1 = new BivariatePolynomial(polynomial1, d1); //initialize Bp1, Bp2 Bp2 = new BivariatePolynomial(polynomial2, d2); } SylvesterMatrix * SM = new SylvesterMatrix(Bp1, Bp2); //construct the sylvester matrix from Bp1 and Bp2 SylvesterPolynomial * SP = new SylvesterPolynomial(SM->getHiddenDeg(), SM->getRowDimension()); //sylvester polynomial of sylvester matrix hidden variable degree SP->SMatrixToSPolynomial(SM); //convert Sylvester Matrix to sylvester polynomial MyMatrix * m = new MyMatrix(SM->getRowDimension(), 1); //random matrix of 1 column (the vector v) /* m->generate(); cout<<"multiplying Sylvester Matrix with"<<endl; m->Print(); SylvesterMatrix * result; SM->multiply(m, result); //multiply the sylvester matrix with the random vector v result->Print(); //print the result //Project 2 code */ ProblemSolver * PS = new ProblemSolver(SP, B, SP->getDegree()); PS->Solve(); findFullSolutions(Bp1, Bp2, PS); changeOfVariable(Bp1, Bp2, SM, PS, B); // delete result; cleanResources(PS, SM, Bp1, Bp2, SP, m); //clean resources }
Iterator interpolation_search(Iterator first, Iterator last, const Tp& val) { typedef typename std::iterator_traits<Iterator>::value_type value_type; typedef typename std::iterator_traits<Iterator>::difference_type difference_type; if (first == last) return first; value_type front = *first; // val <= front if (! (front < val)) return (val < front ? last : first); // we will work with the range of [first, last], not a conventional [first, last) Iterator __last = last; -- last; value_type back = *last; // back <= val if (! (val < back)) return (back < val ? __last : last); // search the range [first + 1, last - 1] value_type pivot; Iterator middle; difference_type diff; difference_type length = std::distance(first, last); __interpolation_pivot<sizeof(value_type)> interpolation; while (length > 1) { diff = 1 + interpolation(val - front, back - front, length - 1); middle = first; std::advance(middle, diff); pivot = *middle; if (pivot < val) { first = middle; front = pivot; length -= diff; } else if (val < pivot) { last = middle; back = pivot; length = diff; } else return middle; } return __last; }
SwaptionVolCube1::Cube::Cube(const Cube& o) { optionTimes_ = o.optionTimes_; swapLengths_ = o.swapLengths_; optionDates_ = o.optionDates_; swapTenors_ = o.swapTenors_; nLayers_ = o.nLayers_; extrapolation_ = o.extrapolation_; transposedPoints_ = o.transposedPoints_; for (Size k=0; k<nLayers_; ++k) { boost::shared_ptr<Interpolation2D> interpolation ( new BilinearInterpolation (optionTimes_.begin(), optionTimes_.end(), swapLengths_.begin(), swapLengths_.end(), transposedPoints_[k])); interpolators_.push_back(boost::shared_ptr<Interpolation2D>( new FlatExtrapolator2D(interpolation))); interpolators_[k]->enableExtrapolation(); } setPoints(o.points_); }
static void recupere_trou(ZONE l,short *tableau) { int trame,avant; for (trame=l->debut;trame<l->fin;) { for (; trame<=l->fin && tableau[trame];trame++); for (avant=trame; trame<=l->fin && !tableau[trame];trame++); while ( avant > l->debut && trame<l->fin && (!tableau[trame] || !ecart_correct(tableau[avant-1],tableau[trame]) ) ) trame++; if (avant > l->debut && trame<l->fin && ecart_correct(tableau[avant-1],tableau[trame]) ) { int debut,fin,i; debut = avant-1; fin = trame; for (i=debut+1;i<fin;i++) tableau[i] = interpolation(debut,tableau[debut],fin,tableau[fin],i); } } }
int main(int argc, char **argv) { FILE *fpint, *fpcp, *fpcs, *fpro; int example, verbose, writeint, nb; int above, diffrwidth, dtype; int Ngp, Ngs, Ngr, Np, Ns, Nr, Ng, Ni, Nv, Nvi, No, Noi; int jint, jcount, j, ix, iz, nx, nz, nxp, nzp, *zp, nmaxx, nminx, optgrad, poly, gradt; int ncp, nro, ncs, nvel, skip, rayfile, store_int; long lseed; size_t nwrite; float *data_out, orig[2], cp0, cs0, ro0; float *x, *z, *var, *interface, **inter; float back[3], sizex, sizez, dx, dz; float **cp ,**cs, **ro, aver, gradlen, gradcp, gradcs, gradro; /* Gradient unit flag */ /* ------------------ */ /* - 0 Unit : m/s per dz */ /* - 1 Unit : m/s per m */ int gradunit; /* Number of Z-reference points (one per layer) */ int Nzr=0; float **gridcp, **gridcs, **gridro; segy *hdrs; FILE *fpout; char *file, intt[10], *file_base, filename[150]; initargs(argc, argv); requestdoc(1); if (!getparint("example", &example)) example=0; else { plotexample(); exit(0); } if(getparstring("file",&file_base)) vwarn("parameters file is changed to file_base"); else { if(!getparstring("file_base",&file_base)) verr("file_base not specified."); } if(getparfloat("back", back)) { vwarn("parameters back is not used anymore"); vwarn("it has changed into cp0 (ro0,cs0 are optional)"); nb = countparval("back"); if (nb == 1) { vwarn("The new call should be cp0=%.1f",back[0]); cp0 = back[0]; } if (nb == 2) { vwarn("The new call should be cp0=%.1f",back[0]); vwarn(" ro0=%.1f",back[1]); cp0 = back[0]; ro0 = back[1]; } if (nb == 3) { vwarn("The new call should be cp0=%.1f",back[0]); vwarn(" cs0=%.1f",back[1]); vwarn(" ro0=%.1f",back[2]); cp0 = back[0]; cs0 = back[1]; ro0 = back[2]; } vmess("Don't worry everything still works fine"); } else { if(!getparfloat("cp0", &cp0)) verr("cp0 not specified."); if(!getparfloat("cs0", &cs0)) cs0 = -1; if(!getparfloat("ro0", &ro0)) ro0 = -1; } if(!getparfloat("sizex", &sizex)) verr("x-model size not specified."); if(!getparfloat("sizez", &sizez)) verr("z-model size not specified."); if(!getparfloat("dx", &dx)) verr("grid distance dx not specified."); if(!getparfloat("dz", &dz)) verr("grid distance dz not specified."); if(!getparfloat("orig", orig)) orig[0] = orig[1] = 0.0; if(!getparint("gradt", &gradt)) gradt = 1; if(!getparint("gradunit", &gradunit)) gradunit = 0; if(!getparint("writeint", &writeint)) writeint = 0; if(!getparint("rayfile", &rayfile)) rayfile = 0; if(!getparint("skip", &skip)) skip = 5; if(!getparint("above", &above)) above=0; if(!getparint("verbose", &verbose)) verbose=0; if(!getparint("dtype", &dtype)) dtype = 0; if ((writeint == 1) || (rayfile == 1)) store_int = 1; else store_int = 0; /*=================== check parameters =================*/ Np = countparname("cp"); Ns = countparname("cs"); Nr = countparname("ro"); Ng = countparname("grad"); No = countparname("poly"); Ni = countparname("intt"); Nv = countparname("var"); Ngp = countparname("gradcp"); Ngs = countparname("gradcs"); Ngr = countparname("gradro"); Nvi = 0; for (jint = 1; jint <= Ni; jint++) { getnparstring(jint,"intt", &file); strcpy(intt, file); if (strstr(intt,"sin") != NULL) Nvi++; if (strstr(intt,"rough") != NULL) Nvi++; if (strstr(intt,"fract") != NULL) Nvi++; if (strstr(intt,"elipse") != NULL) Nvi++; if (strstr(intt,"random") != NULL) Nvi++; // if (strstr(intt,"randdf") != NULL) Nvi++; if (strstr(intt,"diffr") != NULL || strstr(intt,"randdf") != NULL) { Nvi++; // if (Ng != 0) Ng++; // if (No != 0) No++; } } // fprintf(stderr,"Nvi=%d ng=%d No=%d np=%d,", Nvi,Ng,No,Np); if (Np != Nr && ro0 > 0) verr("number of cp and ro not equal."); if (Np != Ni) verr("number of cp and interfaces not equal."); if (Nvi != Nv) verr("number of interface variables(var) not correct."); if (Ns == 0 && Nr == 0) if (verbose>=2) vmess("Velocity model."); if (Ns == 0) { if (verbose>=2) vmess("Acoustic model."); } else { if (verbose>=2) vmess("Elastic model."); if (Np != Ns) verr("number of cp and cs not equal"); } if (Ng == 0) { if (verbose>=2) vmess("No boundary gradients are defined."); } else if (Ng != Np) { verr("number of boundary gradients and interfaces are not equal."); } if (Ngp == 0) { if (verbose>=2) vmess("No interface gradients for cp defined."); } else if (Ngp != Np) { verr("gradcp gradients and interfaces are not equal."); } if (Ngs == 0) { if (verbose>=2) vmess("No interface gradients for cs defined."); } else if (Ngs != Np) { verr("gradcs gradients and interfaces are not equal."); } if (Ngr == 0) { if (verbose>=2) vmess("No interface gradients for rho defined."); } else if (Ngr != Np) { verr("gradro gradients and interfaces are not equal."); } if (No == 0) { if (verbose>=2) vmess("All interfaces are linear."); } // else if (No != Np) { // verr("number of poly variables and interfaces are not equal."); // } if (Np > 0) { if (countparname("x") != Np) verr("a x array must be specified for each interface."); if (countparname("z") != Np) verr("a z array must be specified for each interface."); } else Np = 1; if (Nzr != Np && Nzr !=0) { verr("number of zref gradients not equal to number of interfaces"); } /*=================== initialization of arrays =================*/ nz = NINT(sizez/dz)+1; nx = NINT(sizex/dx)+1; zp = (int *)malloc(nx*sizeof(int)); interface = (float *)malloc(nx*sizeof(float)); var = (float *)malloc(8*sizeof(float)); gridcp = alloc2float(nz, nx); if(gridcp == NULL) verr("memory allocation error gridcp"); if (Ns || (NINT(cs0*1e3) >= 0)) { gridcs = alloc2float(nz, nx); if(gridcs == NULL) verr("memory allocation error gridcs"); } else gridcs = NULL; if (Nr || (NINT(ro0*1e3) >= 0)) { gridro = alloc2float(nz, nx); if(gridro == NULL) verr("memory allocation error gridro"); } else gridro = NULL; cp = alloc2float(nx,3); cs = alloc2float(nx,3); ro = alloc2float(nx,3); if (store_int == 1) inter = alloc2float(nx, 2*Np); if (verbose) { vmess("Origin top left (x,z) . = %.1f, %.1f", orig[0], orig[1]); vmess("Base name ............. = %s", file_base); vmess("Number of interfaces .. = %d", Np); vmess("length in x ........... = %f (=%d)", sizex, nx); vmess("length in z ........... = %f (=%d)", sizez, nz); vmess("delta x ............... = %f", dx); vmess("delta z ............... = %f", dz); vmess("cp0 ................... = %f", cp0); if (Ns) vmess("cs0 ................... = %f", cs0); if (Nr) vmess("ro0 ................... = %f", ro0); vmess("write interfaces ...... = %d", writeint); vmess("store interfaces ...... = %d", store_int); if (above) vmess("define model above interface"); else vmess("define model below interface"); } /*========== initializing for homogeneous background =============*/ nminx = 0; nmaxx = nx; for (j = nminx; j < nmaxx; j++) { cp[0][j] = cp0; cs[0][j] = cs0; ro[0][j] = ro0; zp[j] = 0; cp[1][j] = cp0; cs[1][j] = cs0; ro[1][j] = ro0; } gradlen = 0.0; gradcp = gradcs = gradro = 0.0; optgrad = 3; if (above == 0) { Nvi = 1; Noi = 1; } else { Nvi = Ngp; Noi = Ngp; } grid(gridcp, gridcs, gridro, zp, cp, cs, ro, nminx, nmaxx, optgrad, gradlen, gradcp, gradcs, gradro, dx, dz, nz); nxp = nzp = 2; x = (float *)malloc(nxp*sizeof(float)); z = (float *)malloc(nzp*sizeof(float)); if (Ni == 0) { if (verbose) vmess("No interfaces are defined, Homogeneous model."); Np = 0; } /*========== filling gridded model with interfaces =============*/ for (jcount = 1; jcount <= Np; jcount++) { /* for above interface definition reverse */ /* order of interfaces to scan */ if (above == 0) jint=jcount; else jint=Np+1-jcount; if (verbose) vmess("***** Interface number %d *****", jint); getnparstring(jint,"intt", &file); strcpy(intt, file); nxp = countnparval(jint,"x"); nzp = countnparval(jint,"z"); if (nxp != nzp) { vmess("nxp = %d nzp =%d for interface %d",nxp, nzp, jint); verr("Number of x and z values not equal for interface %d",jint); } ncp = countnparval(jint,"cp"); nro = countnparval(jint,"ro"); ncs = countnparval(jint,"cs"); if (ncp == 1) { if (verbose>=2) vmess("No lateral gradient in P velocity"); } else if (ncp == 2) { if (verbose) vmess("lateral P-gradient from begin to end"); } else if (ncp != nxp) { vmess("ncp = %d nxp =%d for interface %d",ncp, nxp, jint); verr("Number of cp's and x not equal for interface %d",jint); } if (nro <= 1) { if (verbose>=2) vmess("No lateral gradient in density"); } else if (nro == 2) { if (verbose) vmess("lateral Rho-gradient from begin to end"); } else if (nro != nxp) { vmess("nro = %d nxp =%d for interface %d",nro, nxp, jint); verr("Number of ro's and x not equal for interface %d",jint); } if (ncs <= 1) { if (verbose>=2) vmess("No lateral gradient in S velocity"); } else if (ncs == 2) { if (verbose) vmess("lateral S-gradient from begin to end"); } else if (ncs != nxp) { vmess("ncs = %d nxp =%d for interface %d",ncs, nxp, jint); verr("Number of cs's and x not equal for interface %d",jint); } nvel = MAX(ncp, MAX(nro, ncs)); free(x); free(z); x = (float *)malloc(nxp*sizeof(float)); z = (float *)malloc(nzp*sizeof(float)); memset(interface, 0, nx*sizeof(float)); getnparfloat(jint,"x",x); getnparfloat(jint,"z",z); getnparfloat(jint,"cp",cp[2]); if (Nr == 0) ro[2][0] = 0.0; else getnparfloat(jint,"ro", ro[2]); if (Ns == 0) cs[2][0] = 0.0; else getnparfloat(jint,"cs", cs[2]); if (Ng == 0) gradlen = 0.0; else getnparfloat(Noi,"grad", &gradlen); if (No == 0) poly = 0; else getnparint(Noi,"poly", &poly); if (Ngp == 0) gradcp = 0.0; else getnparfloat(Noi,"gradcp", &gradcp); if (Ngs == 0) gradcs = 0.0; else getnparfloat(Noi,"gradcs", &gradcs); if (Ngr == 0) gradro = 0.0; else getnparfloat(Noi,"gradro", &gradro); /* if gradunit is in meters, recalculate gradcp,gradcs and gradro */ if (gradunit > 0) { gradcs = gradcs * dz; gradcp = gradcp * dz; gradro = gradro * dz; } if (nvel != 1) { if (ncp == 1) { for (j = 1; j < nvel; j++) cp[2][j] = cp[2][0]; } if (ncs == 1) { for (j = 1; j < nvel; j++) cs[2][j] = cs[2][0]; } if (nro == 1) { for (j = 1; j < nvel; j++) ro[2][j] = ro[2][0]; } } if (verbose) { vmess("Interface type .......... = %s", intt); vmess("Boundary gradient ....... = %f", gradlen); vmess("Interface gradient cp ... = %f", gradcp); if (Ns) vmess("Interface gradient cs ... = %f", gradcs); if (Nr) vmess("Interface gradient ro ... = %f", gradro); if (verbose>=2) { vmess("Polynomal ............... = %d", poly); vmess("Number of (x,z) points... = %d", nxp); vmess("P-wave velocities ....... = %d", ncp); if (Ns) vmess("S-wave velocities ....... = %d", ncs); if (Nr) vmess("Densities ............... = %d", nro); } for (j = 0; j < nxp; j++) { vmess("x = %6.1f \t z = %6.1f", x[j], z[j]); if (nvel != 1) { vmess(" cp = %f", cp[2][j]); if (Ns) vmess(" cs = %f", cs[2][j]); if (Nr) vmess(" rho = %f", ro[2][j]); } } if (nvel == 1) { vmess(" cp = %f", cp[2][0]); if (Ns) vmess(" cs = %f", cs[2][0]); if (Nr) vmess(" rho = %f", ro[2][0]); } } for (j = 0; j < nxp; j++) { x[j] -= orig[0]; z[j] -= orig[1]; } for (j = 0; j < nxp; j++) { if(x[j] > sizex) verr("x coordinate bigger than model"); if(z[j] > sizez) verr("z coordinate bigger than model"); } if (gradlen > 0) optgrad = gradt; else optgrad = 3; if (strstr(intt,"random") != NULL) { Nv = countnparval(Nvi,"var"); if (Nv != 1) verr("Random interface must have 1 variables."); getnparfloat(Nvi,"var", var); lseed = (long)var[0]; srand48(lseed); gradcp=gradcs=gradro=var[0]; optgrad = 4; if (above == 0) Noi++; else Noi--; if (above == 0) Nvi++; else Nvi--; } if ((strstr(intt,"diffr") == NULL) && (strstr(intt,"randdf") == NULL)) { interpolation(x, z, nxp, nx, poly, &nminx, &nmaxx, dx, cp, cs, ro, nvel, interface); } if ( (strstr(intt,"def") != NULL) || (strstr(intt,"random") != NULL) ) { linearint(zp, nminx, nmaxx, dz, interface); if (above == 0) Noi++; else Noi--; } if (strstr(intt,"sin") != NULL) { Nv = countnparval(Nvi,"var"); if (Nv != 2) verr("Sinus interface must have 2 variables."); getnparfloat(Nvi,"var", var); sinusint(zp, nminx, nmaxx, dz, interface, dx, var[0], var[1]); if (above == 0) Noi++; else Noi--; if (above == 0) Nvi++; else Nvi--; } else if (strstr(intt,"rough") != NULL) { Nv = countnparval(Nvi,"var"); if (Nv != 3) verr("Rough interface must have 3 variables."); getnparfloat(Nvi,"var", var); roughint(zp, nminx, nmaxx, dz, interface, var[0],var[1],var[2]); if (above == 0) Noi++; else Noi--; if (above == 0) Nvi++; else Nvi--; } else if (strstr(intt,"fract") != NULL) { Nv = countnparval(Nvi, "var"); if (Nv != 6) verr("Fractal interface must have 6 variables."); getnparfloat(Nvi,"var", var); fractint(zp, nminx, nmaxx, dx, dz, interface, var[0], var[1], var[2], var[3], var[4], var[5]); if (above == 0) Noi++; else Noi--; if (above == 0) Nvi++; else Nvi--; } else if (strstr(intt,"randdf") != NULL) { float x0, z0, dsx, dsz; int i; Nv = countnparval(Nvi, "var"); if (Nv != 2) verr("randdf interface must have 2 variables: number of points, width."); getnparfloat(Nvi,"var", var); if(!getparint("dtype", &dtype)) dtype = -1; randdf(x, z, nxp, dx, dz, gridcp, gridcs, gridro, cp, cs, ro, interface, zp, nx, sizex, sizez, var[0], (int)var[1], dtype); if (above == 0) Noi++; else Noi--; if (above == 0) Nvi++; else Nvi--; } else if (strstr(intt,"elipse") != NULL) { Nv = countnparval(Nvi, "var"); if (Nv != 2) verr("Elipse interface must have 2 variables."); getnparfloat(Nvi,"var", var); elipse(x, z, nxp, dx, dz, gridcp, gridcs, gridro, cp, cs, ro, interface, zp, nz, nx, var[0], var[1], gradcp, gradcs, gradro); if (above == 0) Noi++; else Noi--; if (above == 0) Nvi++; else Nvi--; } else if ((strstr(intt,"diffr") != NULL)) { Nv = countnparval(Nvi, "var"); if (Nv == 2 || Nv == 1) { getnparfloat(Nvi,"var", var); diffrwidth=(int)var[0]; if (Nv==1) { if(!getparint("dtype", &dtype)) dtype = 0; } else dtype=(int)var[1]; } else { verr("diffr interface must have 1 or 2 variables: width,type."); } diffraction(x, z, nxp, dx, dz, gridcp, gridcs, gridro, cp, cs, ro, interface, zp, nx, diffrwidth, dtype); if (above == 0) Noi++; else Noi--; if (above == 0) Nvi++; else Nvi--; } else { if (above == 0) { grid(gridcp, gridcs, gridro, zp, cp, cs, ro, nminx, nmaxx, optgrad, gradlen, gradcp, gradcs, gradro, dx, dz, nz); } else { gridabove(gridcp, gridcs, gridro, zp, cp, cs, ro, nminx, nmaxx, optgrad, gradlen, gradcp, gradcs, gradro, dx, dz, nz); } } if (store_int == 1) { for(j = 0; j < nminx; j++) inter[jint-1][j] = 0.0; for(j = nminx; j < nmaxx; j++) inter[jint-1][j] = interface[j]; for(j = nmaxx; j < nx; j++) inter[jint-1][j] = 0.0; for(j = 0; j < nminx; j++) inter[jint-1+Np][j] = 0.0; for(j = nminx; j < nmaxx; j++) inter[jint-1+Np][j] = zp[j]*dz; for(j = nmaxx; j < nx; j++) inter[jint-1+Np][j] = 0.0; } } /* end of loop over interfaces */ if (verbose) vmess("Writing data to disk."); hdrs = (segy *) calloc(nx,sizeof(segy)); for(j = 0; j < nx; j++) { hdrs[j].f1= orig[1]; hdrs[j].f2= orig[0]; hdrs[j].d1= dz; hdrs[j].d2= dx; hdrs[j].ns= nz; hdrs[j].trwf= nx; hdrs[j].tracl= j; hdrs[j].tracf= j; hdrs[j].gx = (orig[0] + j*dx)*1000; hdrs[j].scalco = -1000; hdrs[j].timbas = 25; hdrs[j].trid = TRID_DEPTH; } /* due to bug in SU, int-file has to be opened before other files are closed */ if (writeint == 1) { strcpy(filename, file_base); name_ext(filename, "_int"); fpint = fopen(filename,"w"); assert(fpint != NULL); } /* write P-velocities in file */ strcpy(filename, file_base); name_ext(filename, "_cp"); fpcp = fopen(filename,"w"); assert(fpcp != NULL); data_out = (float *)malloc(nx*nz*sizeof(float)); for(ix = 0; ix < nx; ix++) { for(iz = 0; iz < nz; iz++) { data_out[ix*nz+iz] = gridcp[ix][iz]; } nwrite = fwrite( &hdrs[ix], 1, TRCBYTES, fpcp); assert(nwrite == TRCBYTES); nwrite = fwrite( &data_out[ix*nz], sizeof(float), nz, fpcp); assert(nwrite == nz); } fclose(fpcp); free2float(gridcp); /* write S-velocities in file */ if (Ns > 0 || getparfloat("cs0", &cs0)) { strcpy(filename, file_base); name_ext(filename, "_cs"); fpcs = fopen(filename,"w"); assert(fpcs != NULL); for(ix = 0; ix < nx; ix++) { for(iz = 0; iz < nz; iz++) { data_out[ix*nz+iz] = gridcs[ix][iz]; } nwrite = fwrite( &hdrs[ix], 1, TRCBYTES, fpcs); assert(nwrite == TRCBYTES); nwrite = fwrite( &data_out[ix*nz], sizeof(float), nz, fpcs); assert(nwrite == nz); } fclose(fpcs); free2float(gridcs); } /* end of writing S-velocity file */ /* write densities in file */ if (Nr > 0 || getparfloat("ro0", &ro0)) { strcpy(filename, file_base); name_ext(filename, "_ro"); fpro = fopen(filename,"w"); assert(fpro != NULL); for(ix = 0; ix < nx; ix++) { for(iz = 0; iz < nz; iz++) { data_out[ix*nz+iz] = gridro[ix][iz]; } nwrite = fwrite( &hdrs[ix], 1, TRCBYTES, fpro); assert(nwrite == TRCBYTES); nwrite = fwrite( &data_out[ix*nz], sizeof(float), nz, fpro); assert(nwrite == nz); } fclose(fpro); free2float(gridro); } /* end of writing density file */ /* write depths of the interfaces */ if (writeint == 1) { free(hdrs); hdrs = (segy *) calloc(Np,sizeof(segy)); for(j = 0; j < Np; j++) { hdrs[j].fldr = 1; hdrs[j].timbas = 25; hdrs[j].f1= orig[0]; hdrs[j].f2= 0.0; hdrs[j].d1= dx; hdrs[j].d2= dz; hdrs[j].ns= nx; hdrs[j].trwf= Np; hdrs[j].tracl= j; hdrs[j].tracf= j; hdrs[j].trid= TRID_DEPTH; } /* note that due to bug in SU, interface file ha salready been opened */ strcpy(filename, file_base); name_ext(filename, "_int"); free(data_out); data_out = (float *)malloc(nx*Np*sizeof(float)); for(jint = 0; jint < Np; jint++) { for(j = 0; j < nx; j++) { data_out[jint*nx+j] = inter[jint][j]+orig[1]; } nwrite = fwrite( &hdrs[ix], 1, TRCBYTES, fpint); assert(nwrite == TRCBYTES); nwrite = fwrite( &data_out[jint*nx], sizeof(float), nx, fpint); assert(nwrite == nx); } for(j = 0; j < Np; j++) hdrs[j].fldr = 2; for(jint = 0; jint < Np; jint++) { for(j = 0; j < nx; j++) { data_out[jint*nx+j] = inter[jint+Np][j]+orig[1]; } nwrite = fwrite( &hdrs[ix], 1, TRCBYTES, fpint); assert(nwrite == TRCBYTES); nwrite = fwrite( &data_out[jint*nx], sizeof(float), nx, fpint); assert(nwrite == nx); } fclose(fpint); } /* end of writing interface file */ if (rayfile == 1) { strcpy(filename, file_base); strcpy(strrchr(filename, '.'), ".mod"); fpout = fopen(filename, "w+"); fprintf(fpout,"RAYTRACE MODEL FILE\n"); fprintf(fpout,"# ASCII file for ray-tracer\n\n"); fprintf(fpout,"# Top interface\n\n"); fprintf(fpout,"x=0,%.1f\n", sizex); fprintf(fpout,"z=0.,0.\n"); /* for(i = 1; i <= Np; i++) { fprintf(fpout,"\n# %d th interface\n\nx=",i); nxp = countnparval(i,"x"); nzp = countnparval(i,"z"); free(x); free(z); x = (float *)malloc(nxp*sizeof(float)); z = (float *)malloc(nzp*sizeof(float)); getnparfloat(i,"x",x); getnparfloat(i,"z",z); for(j = 0; j < (nxp-1); j ++) fprintf(fpout,"%.1f,", x[j]); fprintf(fpout,"%.1f\nz=", x[nxp-1]); for(j = 0; j < (nxp-1); j ++) fprintf(fpout,"%.1f,", z[j]); fprintf(fpout,"%.1f\n", z[nxp-1]); } */ for(jint = 0; jint < Np; jint++) { fprintf(fpout,"\n# %d th interface\n\nx=0",jint+1); for(j = skip; j < nx; j += skip) fprintf(fpout,",%.1f", (float)j*dx); fprintf(fpout,"\nz=%.1f", inter[jint][0]); for(j = skip; j < nx; j += skip) fprintf(fpout,",%.1f", inter[jint][j]); fprintf(fpout,"\n"); } fprintf(fpout,"\n# %d th interface\n\nx=0",jint+1); for(j = skip; j < nx; j += skip) fprintf(fpout,",%.1f", (float)j*dx); fprintf(fpout,"\nz=%.1f", sizez); for(j = skip; j < nx; j += skip) fprintf(fpout,",%.1f", sizez); fprintf(fpout,"\n"); /**/ fprintf(fpout,"\n\n"); fprintf(fpout,"cp=%.1f,", back[0]); for(jint = 1; jint <= Np; jint++) { aver = 0.0; ncp = countnparval(jint,"cp"); getnparfloat(jint,"cp",cp[2]); for(j = 0; j < ncp; j++) aver += cp[2][j]; aver = aver/((float)ncp); if (jint == Np ) fprintf(fpout,"%.1f", aver); else fprintf(fpout,"%.1f,", aver); } fclose(fpout); free2float(inter); } free(hdrs); return 0; }
void main() { int i, x, s, value, count; float start, finish; unsigned long int j; unsigned int mask=1; long int error, ferror; double progress, b; FILE *fp; if((fp=fopen("data_(63,15)m=1.txt","a"))==NULL) { printf("Can't open the data.txt\n"); exit(0); } fclose(fp); srand(1977); mono_table(); printf("\nEnter start SNR: "); scanf("%f", &start); printf("\nEnter finish SNR: "); scanf("%f", &finish); printf("\nseq_num: "); scanf("%d", &seq_num); for(SNR=start;SNR<=finish;SNR++) { N0=(1.0/(float(k)/float(n)))/pow(10.0, SNR/10.0); sgm=sqrt(N0/2); b=1.0; error=0; //ferror=0; for(j=1;j<=seq_num;j++) { //printf("\n\n*************For the %dth frame*************:\n", j); //Generate binary message for(i=0;i<k*p;i++) bi_message[i]=rand()%2; //Convert to nonbinary for(i=0;i<k;i++) message[i]=bi_message[p*i]+2*bi_message[p*i+1]+4*bi_message[p*i+2]+8*bi_message[p*i+3] +16*bi_message[p*i+4]+32*bi_message[p*i+5]; encoder(); //Convert the codeword into binary for(i=0;i<n;i++) { value=codeword[i]; mask=1; for(x=0;x<p;x++) //for(m=p-1;m>=0;m--) { if((value & mask)>0) bi_codeword[p*i+x]=1; else bi_codeword[p*i+x]=0; mask=mask<<1; } } modulation(); channel(); /////////To be done?//////////// demodulation(); interpolation(); factorization(); //Number of errors calculation //error=0; for(i=0;i<p*n;i++) if(bi_codeword[i]!=dec_codeword[i]) error++; /* if(f_error_temp==1) printf("\nerror=%d\n",error); f_error_temp=0; */ /* if(error!=0) ferror++; */ progress=(double)(j*100)/(double)seq_num; BER=(double)(error)/(double)(n*p*j); //FER=(double)(ferror)/(double)(j), printf("Progress=%0.1f, SNR=%2.1f, Bit Errors=%2.1d, BER=%E\r", progress, SNR, error, BER); // printf(" Progress=%0.1f,dectect=%d\r",progress,dectec); } BER=(double)error/(double)(n*p*seq_num); //FER=(double)(ferror)/(double)(seq_num); printf("Progress=%0.1f, SNR=%2.1f, Bit Errors=%2.1d, BER=%E\n",progress, SNR, error, BER); // printf(" Progress=%0.1f,dectect=%d\r",progress,dectec); fp=fopen("data_(63,15)m=1.txt","a"); fprintf(fp,"Progress=%0.1f, SNR=%2.1f, Bit Errors=%2.1d, BER=%E\n",progress, SNR, error, BER); fclose(fp); } getchar(); getchar(); }
void SE_BipedController::fillFrame() { int maxFrame = findMaxFrameIndex(); std::vector<SE_BipedKeyFrame*> fullFrame; //fullFrame.resize(maxFrame,NULL); for(int i = 0; i < oneBipAnimation.size(); ++i) { //get bip one by one SE_Biped *bip = oneBipAnimation[i]; if(bip->animationInfo.size() == 0) { continue;//this bip has no keyframe } //generate 0 frame, bind_pos relative parent SE_Matrix4f bindposT; if(bip->parent) { bindposT = (bip->parent->bind_pose.inverse()).mul(bip->bind_pose); } else { //this bip is ROOT bindposT = bip->bind_pose; } SE_Quat rotate = bindposT.toMatrix3f().toQuat();//no rotate rotate = rotate.inverse(); SE_Vector3f translate = bindposT.getTranslate(); SE_Vector3f scale(1,1,1); //scale no use SE_BipedKeyFrame *zeroFrame = new SE_BipedKeyFrame(); zeroFrame->frameIndex = 0; zeroFrame->rotateQ = rotate; zeroFrame->scale = scale; zeroFrame->translate = translate; //push first (0) frame to target fullFrame.push_back(zeroFrame); std::vector<SE_BipedKeyFrame*>::iterator it_s = bip->animationInfo.begin(); std::vector<SE_BipedKeyFrame*>::iterator it_t = fullFrame.end(); -- it_t; SE_BipedKeyFrame* node_s = NULL; SE_BipedKeyFrame* node_t = NULL; while(it_s != bip->animationInfo.end()) { node_s = *it_s; node_t = *it_t; if(needInterpolation(node_t->frameIndex,node_s->frameIndex)) { //interpolation interpolation(it_s,it_t,fullFrame); } else if(node_s->frameIndex == node_t->frameIndex)//current source frame index == target frame index { //goto next frame ++it_s; } else //source frame index - target frame index == 1 { //push source frame to target frame vector SE_BipedKeyFrame *nextFrame = new SE_BipedKeyFrame(); //current source node is just next frame nextFrame->frameIndex = node_s->frameIndex; nextFrame->rotateQ = node_s->rotateQ; nextFrame->translate = node_s->translate; nextFrame->scale = node_s->scale; fullFrame.push_back(nextFrame); it_t = fullFrame.end(); --it_t; } } //total frame little than maxFrame? //1.yes fill last frame to vector int lastframe = bip->animationInfo.size() - 1; int lastframeIndex = bip->animationInfo[lastframe]->frameIndex; if(lastframeIndex < maxFrame) { SE_BipedKeyFrame * lastframenode = bip->animationInfo[lastframe]; for(int needfill = 0; needfill < maxFrame - lastframeIndex; ++needfill) { SE_BipedKeyFrame *fillFrame = new SE_BipedKeyFrame(); //next (maxFrame - lastframeIndex) frames are same fillFrame->frameIndex = lastframenode->frameIndex + needfill + 1; fillFrame->rotateQ = lastframenode->rotateQ; fillFrame->translate = lastframenode->translate; fillFrame->scale = lastframenode->scale; fullFrame.push_back(fillFrame); } } //2.no,finish this biped,copy target to source,clear target for(it_s = bip->animationInfo.begin(); it_s != bip->animationInfo.end(); ++it_s) { if(*it_s != NULL) { delete *it_s; } } bip->animationInfo.clear(); bip->animationInfo.resize(fullFrame.size()); //copy target to source std::copy(fullFrame.begin(),fullFrame.end(),bip->animationInfo.begin()); //clear fullFrame vector fullFrame.clear(); } }
bool RotationInstance::ExecuteOn( View& view ) { if ( !view.IsMainView() ) return false; // should never reach this point! AutoViewLock lock( view ); ImageVariant image = view.Image(); if ( image.IsComplexSample() ) return false; double degrees = Round( Deg( p_angle ), 4 ); if ( degrees == 0 ) { Console().WriteLn( "<end><cbr><* Identity *>" ); return true; } ImageWindow window = view.Window(); window.RemoveMaskReferences(); window.RemoveMask(); window.DeletePreviews(); Console().EnableAbort(); StandardStatus status; image.SetStatusCallback( &status ); if ( p_optimizeFast ) switch ( TruncI( degrees ) ) { case 90: Rotate90CCW() >> image; return true; case -90: Rotate90CW() >> image; return true; case 180: case -180: Rotate180() >> image; return true; default: break; } AutoPointer<PixelInterpolation> interpolation( NewInterpolation( p_interpolation, 1, 1, 1, 1, true, p_clampingThreshold, p_smoothness, image ) ); Rotation T( *interpolation, p_angle ); /* * On 32-bit systems, make sure the resulting image requires less than 4 GB. */ if ( sizeof( void* ) == sizeof( uint32 ) ) { int width = image.Width(), height = image.Height(); T.GetNewSizes( width, height ); uint64 sz = uint64( width )*uint64( height )*image.NumberOfChannels()*image.BytesPerSample(); if ( sz > uint64( uint32_max-256 ) ) throw Error( "Rotation: Invalid operation: Target image dimensions would exceed four gigabytes" ); } T.SetFillValues( p_fillColor ); T >> image; return true; }
std::tuple< std::shared_ptr<Matrix>, std::shared_ptr<Matrix> > transfer_operators(const Matrix &A) { typedef typename backend::value_type<Matrix>::type Val; typedef ptrdiff_t Idx; AMGCL_TIC("aggregates"); Aggregates aggr(A, prm.aggr, prm.nullspace.cols); prm.aggr.eps_strong *= 0.5; AMGCL_TOC("aggregates"); AMGCL_TIC("interpolation"); auto P_tent = tentative_prolongation<Matrix>( rows(A), aggr.count, aggr.id, prm.nullspace, prm.aggr.block_size ); // Filter the system matrix backend::crs<Val> Af; Af.set_size(rows(A), cols(A)); Af.ptr[0] = 0; std::vector<Val> dia(Af.nrows); #pragma omp parallel for for(Idx i = 0; i < static_cast<Idx>(Af.nrows); ++i) { Idx row_begin = A.ptr[i]; Idx row_end = A.ptr[i+1]; Idx row_width = row_end - row_begin; Val D = math::zero<Val>(); for(Idx j = row_begin; j < row_end; ++j) { Idx c = A.col[j]; Val v = A.val[j]; if (c == i) D += v; else if (!aggr.strong_connection[j]) { D += v; --row_width; } } dia[i] = D; Af.ptr[i+1] = row_width; } Af.set_nonzeros(Af.scan_row_sizes()); #pragma omp parallel for for(Idx i = 0; i < static_cast<Idx>(Af.nrows); ++i) { Idx row_begin = A.ptr[i]; Idx row_end = A.ptr[i+1]; Idx row_head = Af.ptr[i]; for(Idx j = row_begin; j < row_end; ++j) { Idx c = A.col[j]; if (c == i) { Af.col[row_head] = i; Af.val[row_head] = dia[i]; ++row_head; } else if (aggr.strong_connection[j]) { Af.col[row_head] = c; Af.val[row_head] = A.val[j]; ++row_head; } } } std::vector<Val> omega; auto P = interpolation(Af, dia, *P_tent, omega); auto R = restriction (Af, dia, *P_tent, omega); AMGCL_TOC("interpolation"); if (prm.nullspace.cols > 0) prm.aggr.block_size = prm.nullspace.cols; return std::make_tuple(P, R); }
// multigrid v-cycle void v_cycle( double* P, uint n_dof, cuint nx, cuint ny, cuint nz, cdouble hx, cdouble hy, cdouble hz, cdouble hx2i, cdouble hy2i, cdouble hz2i, cdouble tol, cuint max_iteration, cuint pre_smooth_iteration, cdouble lx, cdouble ly, cdouble lz, cuint level, cuint max_level, double* F, double& Er, double* Uss, double* Vss, double* Wss, cdouble bcs[][6], cdouble dt ) { cout<<"level: "<<level<<" n_dof: "<<n_dof<<endl; // initialize finite difference matrix (+1 for global constraint) // double** M = new double*[n_dof]; // for(int n = 0; n < (n_dof); n++) // M[n] = new double[n_dof]; // // initialize // #pragma omp parallel for shared(n_dof, M) // for(int i=0; i<n_dof; i++) // for(int j=0; j<n_dof; j++) // M[i][j] = 0; cout<<"fd_matrix_sparse"<<endl; vector<tuple <uint, uint, double> > M_sp; vector<double> val; vector<uint> col_ind; vector<uint> row_ptr(1,0); // create finite difference matrix cout<<"create finite difference matrix"<<endl; // build pressure matrix pressure_matrix( M_sp, val, col_ind, row_ptr, nx, ny, nz, hx2i, hy2i, hz2i, n_dof ); // construct load vector // load vector is created only at the level 0 if(level==0){ F = new double[n_dof]; cout<<"create load vector"<<endl; pressure_rhs(F, Uss, Vss, Wss, nx, ny, nz, bcs, hx, hy, hz, dt); // load_vector(F, n_dof, I,J,K ); } // cout<<"save matrix and vector"<<endl; // char matrix_file[100]; // char vector_file[100]; // sprintf(vector_file, "vector_%i.dat", level); // if(write_vector(n_dof,F,vector_file)) cout<<"write_vector fail"<<endl; // construct solution vector double* U; if(level==0) U=P; else U = new double[n_dof]; double* U_tmp = new double[n_dof]; // initial guess #pragma omp parallel for shared(U, U_tmp) num_threads(nt) for(int n=0; n<n_dof; n++){ U[n] = 0.0; U_tmp[n] = 0.0; } // residual and error double* R = new double[n_dof]; // perform pre-smoothing and compute residual cout<<"pre-smoothing "<<pre_smooth_iteration<<" times"<<endl; Er = tol*10; jacobi_sparse(tol, pre_smooth_iteration, n_dof, U, U_tmp, val, col_ind, row_ptr, F, Er, R); // restriction of residual on coarse grid double* F_coar; // Restrict the residual cuint nx_coar = (nx)/2; cuint ny_coar = (ny)/2; cuint nz_coar = (nz)/2; uint n_dof_coar = nx_coar*ny_coar*nz_coar; F_coar = new double[n_dof_coar]; // mesh size cdouble hx_coar = lx/(nx_coar); cdouble hy_coar = ly/(ny_coar); cdouble hz_coar = lz/(nz_coar); // inverse of square of mesh sizes cdouble hx2i_coar = 1.0/(hx_coar*hx_coar); cdouble hy2i_coar = 1.0/(hy_coar*hy_coar); cdouble hz2i_coar = 1.0/(hz_coar*hz_coar); // restric residual to the coarrse grid cout<<"restriction"<<endl; restriction( R, F_coar, nx, ny, nz, nx_coar, ny_coar, nz_coar); // construct solution vector on coarse grid double* U_coar = new double[n_dof_coar]; double* U_coar_tmp = new double[n_dof_coar]; // if the grid is coarsest if( level==max_level){ cout<<"level: "<<level+1<<" n_dof: "<<n_dof_coar<<endl; // initial guess #pragma omp parallel for shared(U_coar, U_coar_tmp) num_threads(nt) for(int n=0; n<n_dof_coar; n++){ U_coar[n] = 0.0; U_coar_tmp[n] = 0.0; } vector<tuple <uint, uint, double> > M_sp_coar; vector<double> val_coar; vector<uint> col_ind_coar; vector<uint> row_ptr_coar(1,0); // create finite difference matrix cout<<"create finite difference matrix"<<endl; // fd_matrix_sparse(M_sp_coar, val_coar, col_ind_coar, row_ptr_coar, // nx_coar,ny_coar,nz_coar, // hx2i_coar, hy2i_coar, hz2i_coar, n_dof_coar ); pressure_matrix( M_sp_coar, val_coar, col_ind_coar, row_ptr_coar, nx_coar, ny_coar, nz_coar, hx2i_coar, hy2i_coar, hz2i_coar, n_dof_coar ); // residual on coarse grid double* R_coar = new double[n_dof_coar]; // exact Jacobi method Er = tol*10; jacobi_sparse(tol, max_iteration, n_dof_coar, U_coar, U_coar_tmp, val_coar, col_ind_coar, row_ptr_coar, F_coar, Er, R_coar); // write_results( U_coar, // n_dof_coar, // I_coar, J_coar, K_coar, // dx_coar, dy_coar, dz_coar, level); delete[] R_coar; // cout<<"R"<<endl; // for(int i=0; i<n_dof; i++) // cout<<R[i]<<endl; } else{ // v_cycle on the coarse grid v_cycle( U_coar, n_dof_coar, nx_coar, ny_coar, nz_coar, hx_coar, hy_coar, hz_coar, hx2i_coar, hy2i_coar, hz2i_coar, tol, max_iteration, pre_smooth_iteration, lx, ly, lz, level+1, max_level, F_coar, Er, Uss, Vss, Wss, bcs, dt ); cdouble dx_coar = lx/(nx_coar); cdouble dy_coar = ly/(ny_coar); cdouble dz_coar = lz/(nz_coar); // // write partial results for test purpose // write_results( U_coar, // n_dof_coar, // I_coar, J_coar, K_coar, // dx_coar, dy_coar, dz_coar, level); } // interpolate to fine grid double* E = new double[n_dof]; interpolation(U_coar, E, nx_coar,ny_coar,nz_coar, nx, ny, nz); // correct the fine grid approximation #pragma omp parallel for shared(U,E) num_threads(nt) for(int i=0; i<n_dof; i++){ // cout<<i<<" "<<U[i]<<" "<<E[i]<<" "<<E[i]/U[i]<<endl; U[i] += E[i]; } // perform post-smoothing and compute residual uint post_smooth_iteration; // if(level==0) post_smooth_iteration=max_iteration; // else // post_smooth_iteration=( pre_smooth_iteration+1)*1000; cout<<"post-smoothing "<<post_smooth_iteration<<" times on level " <<level<<endl; // jacobi(tol, post_smooth_iteration, n_dof, U, U_tmp, M, F, Er, R); Er = tol*10; jacobi_sparse(tol, post_smooth_iteration, n_dof, U, U_tmp, val, col_ind, row_ptr, F, Er, R); // cleanup if (level==0) delete[] F; delete[] U_tmp; delete[] R, F_coar; delete[] E; delete[] U_coar, U_coar_tmp; }
bool SIMULATION_core::adaptation(){ bool adapt; if ( pSimPar->userRequiresAdaptation() ){ // performs an error estimation on saturation and/or pressure solution and verifies if tolerances are obeyed. // If error is greater than tolerance then mesh will be adapted to improve solution quality adapt = calculate_ErrorAnalysis(pErrorAnalysis,theMesh,pSimPar,pGCData,pPPData->get_FuncPointer_GetGradient()); if (adapt){ // retrieve cumulative simulation time pSimPar->retrieveSimulationTime(); pIData->m1 = theMesh; // auxiliary pointer pIData->m2 = MS_newMesh(0); // initialize auxiliary pointer PADMEC_mesh *pm = new PADMEC_mesh; // temporary pointer // preserves current mesh and create a new one adapted makeMeshCopy2(pIData->m1,pm,pPPData->getPressure,pPPData->getSw_old); // mesh adaptation (adapted mesh saved in file. Bad, bad, bad!) pMeshAdapt->rodar(pErrorAnalysis,pIData->m1); // delete any trace of FMDB data structure deleteMesh(theMesh); theMesh = 0; //create a new FMDB data structure with data in file pIData->m1 = MS_newMesh(0); readmesh(pIData->m1,"Final_01.msh"); theMesh = pIData->m1; // take mesh (coords and connectivities) from temporary matrix to m2 (avoid conflicts with FMDB when deleting m1 and theMesh) makeMeshCopy2(pm,pIData->m2,pPPData->setPressure,pPPData->setSaturation); // must be vanished from code in very near future PADMEC_GAMBIARRA(pIData->m1); // structure allocation must be done for saturation and pressure for the new mesh // it will receive interpolated data from m2 to m1 pPPData->allocateTemporaryData(M_numVertices(pIData->m1)); // interpolate data from m2 to m1 interpolation(pIData,pSimPar->getInterpolationMethod()); // transfer Sw and pressure from tmp to main struct pPPData->transferTmpData(); //pSimPar->printOutVTK(theMesh,pPPData,pErrorAnalysis,pSimPar,pGCData,exportSolutionToVTK); // waste old data and get ready for new data pGCData->deallocatePointers(); pGCData->initilize(theMesh); // mesh pre-processor EBFV1_preprocessor(pIData->m1,pGCData); // objects (pSimPar, pMData, pGCData, pPPData) must store new data updatePointersData(theMesh); // data transfer from FMDB to matrices pGCData->dataTransfer(theMesh); // temporary mesh not necessary any more (goodbye!) deleteMesh(pm); delete pm; pm = 0; deleteMesh(pIData->m2); delete pIData->m2; pIData->m2 = 0; } } return adapt; }
/****************************************************************************** | advection ******************************************************************************/ void advection(PARA_DATA *para, REAL **var, int var_type, REAL *d, REAL *d0) { int i, j, k, p, q, r; int imax = para->geom->imax, jmax = para->geom->jmax; int kmax = para->geom->kmax; int IMAX = imax+2, IJMAX = (imax+2)*(jmax+2); int LOCATION; REAL x0, y0, z0, x_1, y_1,z_1; REAL dt = para->mytime->dt; REAL u0, v0, w0, x_min, x_max, y_min, y_max, z_min, z_max; REAL *x = var[X], *y = var[Y], *z = var[Z]; REAL *gx = var[GX], *gy = var[GY], *gz = var[GZ]; REAL *u = var[VX], *v = var[VY], *w = var[VZ]; REAL *flagp = var[FLAGP],*flagu = var[FLAGU],*flagv = var[FLAGV],*flagw = var[FLAGW]; int k1 = para->geom->k1, k2 = para->geom->k2, k3 = para->geom->k3; int i1 = para->geom->i1, i2 = para->geom->i2; int j1 = para->geom->j1, j2 = para->geom->j2; REAL z1 = para->geom->z1, z2 = para->geom->z2 ,z3 = para->geom->z3; REAL x1 = para->geom->x1, x2 = para->geom->x2; REAL y1 = para->geom->y1, y2 = para->geom->y2; REAL Lx = para->geom->Lx, Ly = para->geom->Ly, Lz = para->geom->Lz; switch (var_type) { case VX: { /*--------------------------------------------------------------------------- | Tracing Back and Interplotaing ---------------------------------------------------------------------------*/ FOR_U_CELL if (i>=i1 && i<=i2 && j>j1 && j<=j2 && k<=k2) continue; /*------------------------------------------------------------------------- | Step 1: Tracing Back -------------------------------------------------------------------------*/ u0 = u[IX(i,j,k)]; v0 = 0.5f *((v[IX(i, j,k)]+ v[IX(i, j-1,k)])*( x[IX(i+1,j,k)]-gx[IX(i,j,k)]) +(v[IX(i+1,j,k)]+ v[IX(i+1,j-1,k)])*(gx[IX(i, j,k)]- x[IX(i,j,k)])) /(x[IX(i+1,j,k)]-x[IX(i,j,k)]); w0 = 0.5f *((w[IX(i, j,k)]+ w[IX(i ,j, k-1)])*( x[IX(i+1,j,k)]-gx[IX(i,j,k)]) +(w[IX(i+1,j,k)]+ w[IX(i+1,j, k-1)])*(gx[IX(i, j,k)]- x[IX(i,j,k)]))/(x[IX(i+1,j,k)]-x[IX(i,j,k)]); x0 =gx[IX(i,j,k)] - u0*dt; y0 = y[IX(i,j,k)] - v0*dt; z0 = z[IX(i,j,k)] - w0*dt; p = i; q = j; r = k; if(u0>0) { while(x0<gx[IX(p,q,r)] && flagu[IX(p,q,r)]<0) p -=1; if(flagu[IX(p,q,r)]>0 && x0< gx[IX(p,q,r)]) x0=gx[IX(p,q,r)]; } else { while(x0>gx[IX(p+1,q,r)] && flagu[IX(p+1,q,r)]<0) p +=1; if(flagu[IX(p+1,q,r)]>0 && x0>gx[IX(p+1,q,r)]) x0=gx[IX(p+1,q,r)]; } if(v0>0) { while(y0<y[IX(p,q,r)] && flagu[IX(p,q,r)]<0) q -=1; if(y0<y[IX(p,q,r)] && flagu[IX(p,q,r)]>0) y0=y[IX(p,q+1,r)]; } else { while(y0>y[IX(p,q+1,r)] && flagu[IX(p,q+1,r)]<0) q +=1; if(y0>y[IX(p,q+1,r)] && flagu[IX(p,q+1,r)]>0) y0=y[IX(p,q,r)]; } if(w0>0) { while(z0<z[IX(p,q,r)] && flagu[IX(p,q,r)]<0) r -=1; if(z0<z[IX(p,q,r)] && flagu[IX(p,q,r)]>0) z0=z[IX(p,q,r+1)]; } else { while(z0>z[IX(p,q,r+1)] && flagu[IX(p,q,r+1)]<0) r +=1; if(z0>z[IX(p,q,r+1)] && flagu[IX(p,q,r+1)]>0) z0=z[IX(p,q,r)]; } x_1 = (x0-gx[IX(p,q,r)]) /(gx[IX(p+1, q ,r )]-gx[IX(p,q,r)]); y_1 = (y0- y[IX(p,q,r)]) /(y [IX(p, q+1, r )]- y[IX(p,q,r)]); z_1 = (z0- z[IX(p,q,r)]) /(z [IX(p, q, r+1)]- z[IX(p,q,r)]); /*------------------------------------------------------------------------- | Interpolating for all variables -------------------------------------------------------------------------*/ d[IX(i,j,k)] = interpolation(para, d0, x_1, y_1, z_1, p, q, r); END_FOR /*--------------------------------------------------------------------------- | define the b.c. ---------------------------------------------------------------------------*/ set_bnd(para, var, var_type, d); } break; case VY: { /*--------------------------------------------------------------------------- | Tracing Back and Interplotaing ---------------------------------------------------------------------------*/ FOR_V_CELL if (i>i1 && i<=i2 && j>=j1 && j<=j2 && k<=k2) continue; /*------------------------------------------------------------------------- | Step 1: Tracing Back -------------------------------------------------------------------------*/ u0 = 0.5f* ((u[IX(i,j,k)] + u[IX(i-1,j, k)]) *(y [IX(i,j+1,k)]-gy[IX(i,j,k)]) +(u[IX(i,j+1,k)] + u[IX(i-1,j+1,k)]) *(gy[IX(i,j, k)]-y[IX(i,j,k)]))/(y[IX(i,j+1,k)]-y[IX(i,j,k)]); v0 = v[IX(i,j,k)]; w0 = 0.5f *((w[IX(i,j, k)]+ w[IX(i,j ,k-1)])* (y [IX(i,j+1,k)]- gy[IX(i,j,k)]) +(w[IX(i,j+1,k)]+ w[IX(i,j+1,k-1)])* (gy[IX(i,j, k)]- y [IX(i,j,k)]))/(y[IX(i,j+1,k)]-y[IX(i,j,k)]); x0 = x[IX(i,j,k)] - u0*dt; y0 = gy[IX(i,j,k)] - v0*dt; z0 = z[IX(i,j,k)] - w0*dt; p = i; q = j; r = k; if(u0>0) { while(x0<x[IX(p,q,r)] && flagv[IX(p,q,r)]<0) p -=1; if(flagv[IX(p,q,r)]>0 && x0< x[IX(p,q,r)]) x0=x[IX(p+1,q,r)]; } else { while(x0>x[IX(p+1,q,r)] && flagv[IX(p+1,q,r)]<0) p +=1; if(flagv[IX(p+1,q,r)]>0 && x0>x[IX(p+1,q,r)]) x0=x[IX(p,q,r)]; } if(v0>0) { while(y0<gy[IX(p,q,r)] && flagv[IX(p,q,r)]<0) q -=1; if(y0<gy[IX(p,q,r)] && flagv[IX(p,q,r)]>0) y0=gy[IX(p,q,r)]; } else { while(y0>gy[IX(p,q+1,r)] && flagv[IX(p,q+1,r)]<0) q +=1; if(y0>gy[IX(p,q+1,r)] && flagv[IX(p,q+1,r)]>0) y0=gy[IX(p,q+1,r)]; } if(w0>0) { while(z0<z[IX(p,q,r)] && flagv[IX(p,q,r)]<0) r -=1; if(z0<z[IX(p,q,r)] && flagv[IX(p,q,r)]>0) z0=z[IX(p,q,r+1)]; } else { while(z0>z[IX(p,q,r+1)] && flagv[IX(p,q,r+1)]<0) r +=1; if(z0>z[IX(p,q,r+1)] && flagv[IX(p,q,r+1)]>0) z0=z[IX(p,q,r)]; } x_1 = (x0- x[IX(p,q,r)])/(x [IX(p+1,q, r)]-x [IX(p,q,r)]); y_1 = (y0-gy[IX(p,q,r)])/(gy[IX(p, q+1, r)]-gy[IX(p,q,r)]); z_1 = (z0- z[IX(p,q,r)])/(z [IX(p, q, r+1)]-z [IX(p,q,r)]); /*------------------------------------------------------------------------- | Interpolating for all variables -------------------------------------------------------------------------*/ d[IX(i,j,k)] = interpolation(para, d0, x_1, y_1, z_1, p, q, r); END_FOR /*--------------------------------------------------------------------------- | define the b.c. ---------------------------------------------------------------------------*/ set_bnd(para, var, var_type, d); } break; case VZ: { /*--------------------------------------------------------------------------- | Tracing Back and Interplotaing ---------------------------------------------------------------------------*/ FOR_W_CELL if (i>i1 && i<=i2 && j>j1 && j<=j2 && k<=k2) continue; /*------------------------------------------------------------------------- | Step 1: Tracing Back -------------------------------------------------------------------------*/ u0 = 0.5f*((u[IX(i,j,k )] + u[IX(i-1,j,k )])*(z [IX(i,j,k+1)]-gz[IX(i,j,k)]) +(u[IX(i,j,k+1)] + u[IX(i-1,j,k+1)])*(gz[IX(i,j,k )]- z[IX(i,j,k)]))/(z[IX(i,j,k+1)]-z[IX(i,j,k)]); v0 = 0.5f*((v[IX(i,j,k )] + v[IX(i,j-1,k )])*(z [IX(i,j,k+1)]-gz[IX(i,j,k)]) +(v[IX(i,j,k+1)] + v[IX(i,j-1,k+1)])*(gz[IX(i,j,k )]-z [IX(i,j,k)]))/(z[IX(i,j,k+1)]-z[IX(i,j,k)]); w0 = w[IX(i,j,k)]; x0 = x[IX(i,j,k)] - u0*dt; y0 = y[IX(i,j,k)] - v0*dt; z0 = gz[IX(i,j,k)] - w0*dt; p = i; q = j; r = k; if(u0>0) { while(x0<x[IX(p,q,r)] && flagw[IX(p,q,r)]<0) p -=1; if(flagw[IX(p,q,r)]>0 && x0< x[IX(p,q,r)]) x0=x[IX(p+1,q,r)]; } else { while(x0>x[IX(p+1,q,r)] && flagw[IX(p+1,q,r)]<0) p +=1; if(flagw[IX(p+1,q,r)]>0 && x0>x[IX(p+1,q,r)]) x0=x[IX(p,q,r)]; } if(v0>0) { while(y0<y[IX(p,q,r)] && flagw[IX(p,q,r)]<0) q -=1; if(y0<y[IX(p,q,r)] && flagw[IX(p,q,r)]>0) y0=y[IX(p,q+1,r)]; } else { while(y0>y[IX(p,q+1,r)] && flagw[IX(p,q+1,r)]<0) q +=1; if(y0>y[IX(p,q+1,r)] && flagw[IX(p,q+1,r)]>0) y0=y[IX(p,q,r)]; } if(w0>0) { while(z0<gz[IX(p,q,r)] && flagw[IX(p,q,r)]<0) r -=1; if(z0<gz[IX(p,q,r)] && flagw[IX(p,q,r)]>0) z0=gz[IX(p,q,r)]; } else { while(z0>gz[IX(p,q,r+1)] && flagw[IX(p,q,r+1)]<0) r +=1; if(z0>gz[IX(p,q,r+1)] && flagw[IX(p,q,r+1)]>0) z0=gz[IX(p,q,r+1)]; } x_1 = (x0- x[IX(p,q,r)])/( x[IX(p+1,q, r )]- x[IX(p,q,r)]); y_1 = (y0- y[IX(p,q,r)])/( y[IX(p, q+1, r )]- y[IX(p,q,r)]); z_1 = (z0-gz[IX(p,q,r)])/(gz[IX(p, q, r+1)]-gz[IX(p,q,r)]); /*------------------------------------------------------------------------- | Interpolating for all variables -------------------------------------------------------------------------*/ d[IX(i,j,k)] = interpolation(para, d0, x_1, y_1, z_1, p, q, r); END_FOR /*--------------------------------------------------------------------------- | define the b.c. ---------------------------------------------------------------------------*/ set_bnd(para, var, var_type, d); } break; } } // End of semi_Lagrangian( )
/****************************************************************************** Trace the VX ******************************************************************************/ int trace_vx(PARA_DATA *para, REAL **var, int var_type, REAL *d, REAL *d0, int **BINDEX) { int i, j, k; int it; int itmax = 20000; // Max number of iterations for backward tracing int imax = para->geom->imax, jmax = para->geom->jmax; int kmax = para->geom->kmax; int IMAX = imax+2, IJMAX = (imax+2)*(jmax+2); REAL x_1, y_1, z_1; REAL dt = para->mytime->dt; REAL u0, v0, w0; REAL *x = var[X], *y = var[Y], *z = var[Z]; REAL *gx = var[GX], *gy = var[GY], *gz = var[GZ]; REAL *u = var[VX], *v = var[VY], *w = var[VZ]; REAL *flagu = var[FLAGU]; REAL Lx = para->geom->Lx, Ly = para->geom->Ly, Lz = para->geom->Lz; int COOD[3], LOC[3]; REAL OL[3]; int OC[3]; FOR_U_CELL if(flagu[IX(i,j,k)]>=0) continue; /*----------------------------------------------------------------------- | Step 1: Tracing Back -----------------------------------------------------------------------*/ // Get velocities at the location of VX u0 = u[IX(i,j,k)]; v0 = 0.5 * ((v[IX(i, j,k)]+v[IX(i, j-1,k)])*( x[IX(i+1,j,k)]-gx[IX(i,j,k)]) +(v[IX(i+1,j,k)]+v[IX(i+1,j-1,k)])*(gx[IX(i, j,k)]- x[IX(i,j,k)])) / (x[IX(i+1,j,k)]-x[IX(i,j,k)]); w0 = 0.5 * ((w[IX(i, j,k)]+w[IX(i ,j, k-1)])*( x[IX(i+1,j,k)]-gx[IX(i,j,k)]) +(w[IX(i+1,j,k)]+w[IX(i+1,j, k-1)])*(gx[IX(i, j,k)]- x[IX(i,j,k)])) / (x[IX(i+1,j,k)]-x[IX(i,j,k)]); // Find the location at previous time step OL[X] =gx[IX(i,j,k)] - u0*dt; OL[Y] = y[IX(i,j,k)] - v0*dt; OL[Z] = z[IX(i,j,k)] - w0*dt; // Initialize the coordinates of previous step OC[X] = i; OC[Y] = j; OC[Z] = k; //OC is the trace back coodinates // Initialize the signs for track process // Completed: 0; In process: 1 COOD[X] = 1; COOD[Y] = 1; COOD[Z] = 1; // Initialize the signs for recording if the track back hits the boundary // Hit the boundary: 0; Not hit the boundary: 1 LOC[X] = 1; LOC[Y] = 1; LOC[Z] = 1; //Initialize the number of iterations it=1; // Trace back more if the any of the trace is still in process while(COOD[X]==1 || COOD[Y] ==1 || COOD[Z] ==1) { it++; // If trace in X is in process and donot hit the boundary if(COOD[X]==1 && LOC[X]==1) set_x_location(para, var, flagu, gx, u0, i, j, k, OL, OC, LOC, COOD); // If trace in Y is in process and donot hit the boundary if(COOD[Y]==1 && LOC[Y]==1) set_y_location(para, var, flagu, y, v0, i, j, k, OL, OC, LOC, COOD); // If trace in Z is in process and donot hit the boundary if(COOD[Z]==1 && LOC[Z]==1) set_z_location(para, var, flagu, z, w0, i, j, k, OL, OC, LOC, COOD); if(it>itmax) { printf("Error: advection.c, can not track the location for VX(%d, %d,%d)", i, j, k); printf("after %d iterations.\n", it); return 1; } } // End of while() for backward tracing // Set the coordinates of previous location if it is as boundary if(u0>0 && LOC[X]==0) OC[X] -=1; if(v0>0 && LOC[Y]==0) OC[Y] -=1; if(w0>0 && LOC[Z]==0) OC[Z] -=1; // Fixme: Do not understand here. Should it be // if(u0<0 && LOC[X] = 0) OC[X] += 1; if(u0<0 && LOC[X]==1) OC[X] -=1; if(v0<0 && LOC[Y]==1) OC[Y] -=1; if(w0<0 && LOC[Z]==1) OC[Z] -=1; /*------------------------------------------------------------------------- | Interpolate -------------------------------------------------------------------------*/ x_1 = (OL[X]-gx[IX(OC[X],OC[Y],OC[Z])]) / (gx[IX(OC[X]+1,OC[Y],OC[Z])]-gx[IX(OC[X],OC[Y],OC[Z])]); y_1 = (OL[Y]-y[IX(OC[X],OC[Y],OC[Z])]) / (y[IX(OC[X],OC[Y]+1,OC[Z])]-y[IX(OC[X],OC[Y],OC[Z])]); z_1 = (OL[Z]-z[IX(OC[X],OC[Y],OC[Z])]) / (z[IX(OC[X],OC[Y],OC[Z]+1)]-z[IX(OC[X],OC[Y],OC[Z])]); d[IX(i,j,k)] = interpolation(para, d0, x_1, y_1, z_1, OC[X], OC[Y], OC[Z]); END_FOR // End of loop for all cells /*--------------------------------------------------------------------------- | define the b.c. ---------------------------------------------------------------------------*/ set_bnd(para, var, var_type, d, BINDEX); return 0; } // End of trace_vx()
static Point _sogouToGoogleMars(const double lo, const double la) { // clock_t start = clock(); #ifdef VERBOSE printf("Input: %d, %d\n", (int)lo, (int)la); #endif // 初始化数据 Node heap[NEIBOR_NUM]; //double buff0[N], buff1[N]; const int lo1e5 = (int)lo; const int la1e5 = (int)la; int loIndex = GET_LO_IDX(lo1e5); int laIndex = GET_LA_IDX(la1e5); loIndex = min(max(loIndex, 0), BUCKET_SIZE_LO - 1); laIndex = min(max(laIndex, 0), BUCKET_SIZE_LA - 1); // printf( "Lo Index: %d, La Index: %d\n", loIndex, laIndex); int len = 0; int i, j; int64 step = 0; // step * scale (scale == 1) while (1) { int step1 = step - 1; int to_continue = (len < NEIBOR_NUM) || (heap[0].dist > (step1 * step1 * 10000000000ll)); #ifdef VERBOSE1 int64 step2 = (step * step * 10000000000ll); printf("ToContinue: %d, %lld, %lld\n", to_continue, heap[0].dist, step2); #endif if (!to_continue) { break; } if (step == 0) { processList(buckets[loIndex][laIndex], lo1e5, la1e5, heap, &len); } else { // including both ends j = laIndex - step; if (j >= 0) { for (i = max(0, loIndex - step); i <= min(loIndex + step, BUCKET_SIZE_LO - 1); i++) { processList(buckets[i][j], lo1e5, la1e5, heap, &len); } } // not including end points i = loIndex + step; if (i < BUCKET_SIZE_LO) { for (j = max(0, laIndex - step + 1); j <= min(laIndex + step - 1, BUCKET_SIZE_LA - 1); j++) { processList(buckets[i][j], lo1e5, la1e5, heap, &len); } } // 下面 j = laIndex + step; if (j < BUCKET_SIZE_LA) { for (i = min(BUCKET_SIZE_LO - 1, loIndex + step); i >= max(0, loIndex - step); --i) { processList(buckets[i][j], lo1e5, la1e5, heap, &len); } } // not including end points i = loIndex - step; if (i >= 0) { for (j = min(BUCKET_SIZE_LA - 1, laIndex + step - 1); j >= min(0, laIndex - step + 1); --j) { processList(buckets[i][j], lo1e5, la1e5, heap, &len); } } } step++; } return interpolation(lo, la, heap); }
int main(int argc, char *argv[]) { if (argc != 4) { fprintf(stderr, "Usage: %s <bmp frame 1> <bmp frame 2> <bmp MC out>\n", argv[0]); return -1; } clock_t start_time = clock(); int err_code = 0; try { // Read the input image bmp_in in[2]; if ((err_code = bmp_in__open(&in[0], argv[1])) != 0) throw err_code; if ((err_code = bmp_in__open(&in[1], argv[2])) != 0) throw err_code; int width = in[0].cols, height = in[0].rows; if ((width != in[1].cols) || (height != in[1].rows)) { fprintf(stderr, "The two input frames have different dimensions.\n"); return -1; } my_image_comp mono[2]; mono[0].init(height, width, 4); // Leave a border of 4 (in case needed) mono[1].init(height, width, 4); // Leave a border of 4 (in case needed) mono[0].perform_boundary_extension(); int n, r, c; int num_comps = in[0].num_components; io_byte *line = new io_byte[width*num_comps]; for (n = 0; n < 2; n++) { for (r = height - 1; r >= 0; r--) { // "r" holds the true row index we are reading, since the image // is stored upside down in the BMP file. if ((err_code = bmp_in__get_line(&(in[n]), line)) != 0) throw err_code; io_byte *src = line; // Points to first sample of component n int *dst = mono[n].buf + r * mono[n].stride; for (c = 0; c < width; c++, src += num_comps) dst[c] = *src; } bmp_in__close(&(in[n])); } // Allocate storage for the motion compensated output my_image_comp output; output.init(height, width, 0); // Don't need a border for output my_image_comp inter,ref_frame; inter.init(height * 2, width * 2, 4); ref_frame.init(height * 4, width * 4, 4); interpolation(&mono[0], &inter); interpolation(&inter, &ref_frame); my_image_comp output_comps[3]; for (int i = 0; i < 3; ++i) { output_comps[i].init(height, width, 0); } for (int r = 0; r < height; ++r) for (int c = 0; c < width; ++c) { output_comps[0].buf[r * output_comps[0].stride + c] = (mono[1].buf[r * mono[1].stride + c] >> 1) + 128; output_comps[1].buf[r * output_comps[1].stride + c] = (mono[1].buf[r * mono[1].stride + c] >> 1) + 128; output_comps[2].buf[r * output_comps[2].stride + c] = (mono[1].buf[r * mono[1].stride + c] >> 1) + 128; } // Now perform simple motion estimation and compensation int nominal_block_width = nominal_block_size; int nominal_block_height = nominal_block_size; int block_width, block_height; FILE *fp; fopen_s(&fp, "Logdata.m", "w"); fprintf_s(fp, "myvec = ["); for (r = 0; r < height; r += block_height) { block_height = nominal_block_height; if ((r + block_height) > height) block_height = height - r; for (c = 0; c < width; c += block_width) { block_width = nominal_block_width; if ((c + block_width) > width) block_width = width - c; mvector vec = find_motion(&(ref_frame), &(mono[1]), r, c, block_width, block_height, 4); fprintf_s(fp, "%f,%f;\n",vec.x, vec.y); motion_comp(&(ref_frame), &output, vec, r, c, block_width, block_height, 4); draw_line(&(mono[1]), &output_comps[1], vec, r, c, block_width, block_height); } } fprintf_s(fp, "];"); /* for (int r = 0; r < height; ++r) for (int c = 0; c < width; ++c) { output_comps[0].buf[r * output_comps[0].stride + c] = (output.buf[r * output.stride + c]); output_comps[1].buf[r * output_comps[1].stride + c] = (output.buf[r * output.stride + c]); output_comps[2].buf[r * output_comps[2].stride + c] = (output.buf[r * output.stride + c]); } */ float sum = 0; for (int r = 0; r < height; ++r) for (int c = 0; c < width; ++c) { float diff = 0; diff = mono[1].buf[r * mono[1].stride + c] - output.buf[r * output.stride + c]; diff *= diff; sum += diff; } sum = sum / (width * height); printf("The MSE is %f \r\n", sum); // Write the motion compensated image out bmp_out out; if ((err_code = bmp_out__open(&out, argv[3], width, height, 3)) != 0) throw err_code; io_byte *out_line = new io_byte[width * 3]; for (r = height - 1; r >= 0; r--) { // "r" holds the true row index we are writing, since the image is // written upside down in BMP files. for (n = 0; n < 3; n++) { io_byte *dst = out_line + n; // Points to first sample of component n int *src = output_comps[n].buf + r * output_comps[n].stride; for (int c = 0; c < width; c++, dst += 3) { if (src[c] > 255) { src[c] = 255; } else if (src[c] < 0) { src[c] = 0; } *dst = (io_byte)src[c]; } } bmp_out__put_line(&out, out_line); } bmp_out__close(&out); delete[] line; clock_t end_time = clock(); float elaps = ((float)(end_time - start_time)) / CLOCKS_PER_SEC; printf_s("The runtime is %f seconds!\n\r", elaps); system("Pause"); } catch (int exc) { if (exc == IO_ERR_NO_FILE) fprintf(stderr, "Cannot open supplied input or output file.\n"); else if (exc == IO_ERR_FILE_HEADER) fprintf(stderr, "Error encountered while parsing BMP file header.\n"); else if (exc == IO_ERR_UNSUPPORTED) fprintf(stderr, "Input uses an unsupported BMP file format.\n Current " "simple example supports only 8-bit and 24-bit data.\n"); else if (exc == IO_ERR_FILE_TRUNC) fprintf(stderr, "Input or output file truncated unexpectedly.\n"); else if (exc == IO_ERR_FILE_NOT_OPEN) fprintf(stderr, "Trying to access a file which is not open!(?)\n"); return -1; } return 0; }
static void extension_zone(int accrochage,int debut,int fin,int to,short *tableau) { #define POURCENTAGE 25 #define SEUIL 20 #define MAUVAIS_CHEMIN() #define ECART_CORRECT(a,b) ( (maximum(a,b) - minimum(a,b)) < minimum(SEUIL,(POURCENTAGE * minimum(a,b) / 100)) ) int trame,avant,i,m,j; RESULT table[AVANCE+1][cst_pics_amdf]; RESULT normal[cst_pics_amdf]; tableau[accrochage] = avant = to; /* ---------------on etend a gauche ---------------------------*/ for (trame=accrochage;trame>debut;) { table[0][0].rang = avant; for (i=1;i<=AVANCE && trame-i >=debut; i++) trier(trame-i,table[i-1][0].rang,table[i]); trier( m=maximum(trame-AVANCE , debut) ,avant,normal); i--; if ( table[i][0].rang != -1 && normal[0].rang != -1 && table[i][0].rang && normal[0].rang && avant && abs(TO_FREQ(table[i][0].rang) - TO_FREQ(avant)) > abs(TO_FREQ(normal[0].rang) - TO_FREQ(avant)) ) { for (j=1;j<=i; j++) tableau[trame-j] = interpolation(trame,avant,m,normal[0].rang,trame-j); trame -= i; avant = normal[0].rang; } else { if ( table[1][0].rang && ECART_CORRECT(TO_FREQ(avant),TO_FREQ(table[1][0].rang))) avant = tableau[--trame] = table[1][0].rang; else tableau[--trame] = 0; } } /* ------------------ on etend a droite -----------------------*/ avant = tableau[accrochage]; for (trame=accrochage;trame<fin;) { table[0][0].rang = avant; for (i=1;i<=AVANCE && trame+i <= fin; i++) trier(trame+i,table[i-1][0].rang,table[i]); trier( m = minimum(trame+AVANCE , fin) ,avant,normal); i--; if ( table[i][0].rang != -1 && normal[0].rang != -1 && table[i][0].rang && normal[0].rang && avant && abs(TO_FREQ(table[i][0].rang) - TO_FREQ(avant)) > abs(TO_FREQ(normal[0].rang) - TO_FREQ(avant)) ) { for (j=1;j<=i; j++) tableau[trame+j] = interpolation(trame,avant,m,normal[0].rang,trame+j); trame += i; avant = normal[0].rang; } else { if ( table[1][0].rang && ECART_CORRECT(TO_FREQ(avant),TO_FREQ(table[1][0].rang))) avant = tableau[++trame] = table[1][0].rang; else tableau[++trame] = 0; } } #undef MAUVAIS_CHEMIN #undef SEUIL #undef ECART_CORRECT #undef POURCENTAGE }
/* Stabilize given image buffer using stabilization data for * a specified frame number. * * NOTE: frame number should be in clip space, not scene space */ ImBuf *BKE_tracking_stabilize_frame(MovieTracking *tracking, int framenr, ImBuf *ibuf, float translation[2], float *scale, float *angle) { float tloc[2], tscale, tangle; MovieTrackingStabilization *stab = &tracking->stabilization; ImBuf *tmpibuf; int width = ibuf->x, height = ibuf->y; float aspect = tracking->camera.pixel_aspect; float mat[4][4]; int j, filter = tracking->stabilization.filter; void (*interpolation)(struct ImBuf *, struct ImBuf *, float, float, int, int) = NULL; int ibuf_flags; if (translation) copy_v2_v2(tloc, translation); if (scale) tscale = *scale; /* Perform early output if no stabilization is used. */ if ((stab->flag & TRACKING_2D_STABILIZATION) == 0) { if (translation) zero_v2(translation); if (scale) *scale = 1.0f; if (angle) *angle = 0.0f; return ibuf; } /* Allocate frame for stabilization result. */ ibuf_flags = 0; if (ibuf->rect) ibuf_flags |= IB_rect; if (ibuf->rect_float) ibuf_flags |= IB_rectfloat; tmpibuf = IMB_allocImBuf(ibuf->x, ibuf->y, ibuf->planes, ibuf_flags); /* Calculate stabilization matrix. */ BKE_tracking_stabilization_data_get(tracking, framenr, width, height, tloc, &tscale, &tangle); BKE_tracking_stabilization_data_to_mat4(ibuf->x, ibuf->y, aspect, tloc, tscale, tangle, mat); invert_m4(mat); if (filter == TRACKING_FILTER_NEAREST) interpolation = nearest_interpolation; else if (filter == TRACKING_FILTER_BILINEAR) interpolation = bilinear_interpolation; else if (filter == TRACKING_FILTER_BICUBIC) interpolation = bicubic_interpolation; else /* fallback to default interpolation method */ interpolation = nearest_interpolation; /* This function is only used for display in clip editor and * sequencer only, which would only benefit of using threads * here. * * But need to keep an eye on this if the function will be * used in other cases. */ #pragma omp parallel for if (tmpibuf->y > 128) for (j = 0; j < tmpibuf->y; j++) { int i; for (i = 0; i < tmpibuf->x; i++) { float vec[3] = {i, j, 0.0f}; mul_v3_m4v3(vec, mat, vec); interpolation(ibuf, tmpibuf, vec[0], vec[1], i, j); } } if (tmpibuf->rect_float) tmpibuf->userflags |= IB_RECT_INVALID; if (translation) copy_v2_v2(translation, tloc); if (scale) *scale = tscale; if (angle) *angle = tangle; return tmpibuf; }
bool SIMULATION_core::adaptation(){ // let's suppose adaptation will not be necessary bool adapt = false; pSimPar->set_adapt_occur(false); // temporary for debug purposes string filename("simulation-parameters/FS-2D-homogeneo/pp-data-files/adapted_mesh_on_wells.msh"); if ( pSimPar->userRequiresAdaptation() ){ // performs an error estimation on saturation and/or pressure solution and verifies if tolerances are obeyed. // If error is greater than tolerance then mesh will be adapted to improve solution quality std::list<int> elemList; std::map<int,double> nodeMap; bool adapt = calculate_ErrorAnalysis(pErrorAnalysis,pSimPar,pGCData,PhysicPropData::getGradient,elemList,nodeMap); pSimPar->printOutVTK(theMesh,pPPData,pErrorAnalysis,pSimPar,pGCData,exportSolutionToVTK); if (adapt){ // let other simulation code parts aware of the occurrence of the adaptation process pSimPar->set_adapt_occur(true); // retrieve cumulative simulation time pSimPar->retrieveSimulationTime(); pIData->m2 = theMesh; // auxiliary pointer //pIData->m2 = MS_newMesh(0); // initialize auxiliary pointer //PADMEC_mesh *pm = new PADMEC_mesh; // temporary pointer // preserves current mesh and create a new one adapted //makeMeshCopy2(pIData->m1,pm,pPPData->getPressure,pPPData->getSw_old); // mesh adaptation (adapted mesh saved in file. Bad, bad, bad!) //pMeshAdapt->run(pIData->m1,elemList,nodeMap); // clean up //elemList.clear(); //nodeMap.clear(); // delete any trace of FMDB data structure //deleteMesh(theMesh); theMesh = 0; //create a new FMDB data structure with data in file pIData->m1 = MS_newMesh(0); readmesh(pIData->m1,filename.c_str()); theMesh = pIData->m1; // take mesh (coords and connectivities) from temporary matrix to m2 (avoid conflicts with FMDB when deleting m1 and theMesh) //makeMeshCopy2(pm,pIData->m2,pPPData->setPressure,pPPData->setSaturation); // before interpolate data from the old to the new mesh, vectors where pressure and saturation are stored // must be allocated for the new mesh (it has just to be created) pPPData->allocateTemporaryData(M_numVertices(pIData->m1)); // interpolate data from m2 to m1 interpolation(pIData,pSimPar->getInterpolationMethod()); // transfer Sw and pressure from tmp to main struct pPPData->transferTmpData(); // waste old data and get ready for new data pGCData->deallocatePointers(0); // mesh pre-processor EBFV1_preprocessor(pIData->m1,pGCData); // initialize geometric coefficients pointer pGCData->initilize(theMesh); // objects (pSimPar, pMData, pGCData, pPPData) must store new data updatePointersData(theMesh); // data transfer from FMDB to matrices pGCData->dataTransfer(theMesh); pSimPar->printOutVTK(pIData->m1,pPPData,pErrorAnalysis,pSimPar,pGCData,exportSolutionToVTK); STOP(); // temporary mesh not necessary any more (goodbye!) //deleteMesh(pm); //delete pm; pm = 0; deleteMesh(pIData->m2); delete pIData->m2; pIData->m2 = 0; } } return adapt; }
void main() { int i, x, s, start, finish, value, count; unsigned long int j; unsigned int mask=1; long int error, ferror; double progress, b; srand(1977); mono_table(); /* //*********debug********* printf("mono_table:\n"); for(j=0;j<mono_size;j++) { for(i=0;i<mono_size;i++) printf("\t%d",mono_order[j][i]); printf("\n"); } //******************* */ printf("\nEnter start SNR: "); scanf("%d", &start); printf("\nEnter finish SNR: "); scanf("%d", &finish); printf("\nseq_num: "); scanf("%d", &seq_num); for(SNR=start;SNR<=finish;SNR++) { N0=(1.0/(float(k)/float(n)))/pow(10.0, float(SNR)/10.0); sgm=sqrt(N0/2); b=1.0; error=0; //ferror=0; for(j=1;j<=seq_num;j++) { //printf("\n\n*************For the %dth frame*************:\n", j); //Generate binary message for(i=0;i<k*p;i++) bi_message[i]=rand()%2; //Convert to nonbinary for(i=0;i<k;i++) message[i]=bi_message[p*i]+2*bi_message[p*i+1]+4*bi_message[p*i+2]+8*bi_message[p*i+3]; /* //******debug******* message[0]=6; message[1]=9; message[2]=2; message[3]=6; message[4]=10; message[5]=8; message[6]=2; message[7]=0; message[8]=0; */ //******************* encoder(); //Convert the codeword into binary for(i=0;i<n;i++) { value=codeword[i]; mask=1; for(x=0;x<p;x++) //for(m=p-1;m>=0;m--) { if((value & mask)>0) bi_codeword[p*i+x]=1; else bi_codeword[p*i+x]=0; mask=mask<<1; } } modulation(); channel(); /////////To be done?//////////// demodulation(); interpolation(); factorization(); //Number of errors calculation //error=0; for(i=0;i<p*n;i++) if(bi_codeword[i]!=dec_codeword[i]) error++; /* if(f_error_temp==1) printf("\nerror=%d\n",error); f_error_temp=0; */ /* if(error!=0) ferror++; */ progress=(double)(j*100)/(double)seq_num; BER=(double)(error)/(double)(n*p*j); //FER=(double)(ferror)/(double)(j), printf("Progress=%0.1f, SNR=%2.1d, Bit Errors=%2.1d, BER=%E\r", progress, SNR, error, BER); // printf(" Progress=%0.1f,dectect=%d\r",progress,dectec); } BER=(double)error/(double)(n*p*seq_num); //FER=(double)(ferror)/(double)(seq_num); printf("Progress=%0.1f, SNR=%2.1d, Bit Errors=%2.1d, BER=%E\n",progress, SNR, error, BER); // printf(" Progress=%0.1f,dectect=%d\r",progress,dectec); } getchar(); getchar(); }
int main(int argc, char* argv[]) { int nang, N; float dx, dz; int nx, nz; float ox, oz; int gnx, gnz; float gdx, gdz, gox, goz; struct point length; int inter; float TETAMAX, alpha2; FILE *outfile; int ii; int rays, wfront, gap; int lomx, first; int nr, nrmax, nt; int prcube, pr, ste; int ns, nou; float DSmax, dt, T, freq; float *vel; float ds, os, goox; float xmin, xmax, zmin, zmax; float depth; struct point *pos; struct heptagon *cube; struct grid *out; sf_file inp, ampl, time; sf_init(argc,argv); inp = sf_input("in"); /* GET MODEL PARAMETERS */ if (!sf_histint(inp,"n1",&nz)) sf_error("No n1= in input"); if (!sf_histint(inp,"n2",&nx)) sf_error("No n2= in input"); if (!sf_histfloat(inp,"d1",&dz)) sf_error("No d1= in input"); if (!sf_histfloat(inp,"d2",&dx)) sf_error("No d2= in input"); if (!sf_histfloat(inp,"o1",&oz)) sf_error("No o1= in input"); if (!sf_histfloat(inp,"o2",&ox)) sf_error("No o2= in input"); /* GET TRACING PARAMETERS */ if(!sf_getint("nang",&nang)) nang = 10; /* Number of take-off angles */ if(!sf_getint("rays",&rays)) rays = 0; /* If draw rays */ if(!sf_getint("wfront",&wfront)) wfront = 0; /* If draw wavefronts */ if(!sf_getint("gap",&gap)) gap = 1; /* Draw wavefronts every gap intervals */ if(!sf_getint("inter",&inter)) inter = 1; /* If use linear interpolation */ if(!sf_getfloat("DSmax",&DSmax)) DSmax = 5; /* Maximum distance between contiguos points of a wavefront */ if(!sf_getfloat("dt",&dt)) dt = 0.0005; /* time step */ if(!sf_getint("nt",&nt)) nt = 5; /* Number of time steps between wavefronts */ if(!sf_getint("nrmax",&nrmax)) nrmax = 2000; /* Maximum number of points that define a wavefront */ if(!sf_getint("lomx",&lomx)) lomx = 1; /* Use Lomax's waveray method */ if(!sf_getint("first",&first)) first = 1; /* Obtain first arrivals only */ if(!sf_getint("nou",&nou)) nou = 6; /* GET GRIDDING PARAMETERS */ if(!sf_getint("gnx",&gnx)) gnx = nx; /* Coordinates of output grid */ if(!sf_getint("gnz",&gnz)) gnz = nz; if(!sf_getfloat("gdx",&gdx)) gdx = dx; if(!sf_getfloat("gdz",&gdz)) gdz = dz; if(!sf_getfloat("gox",&goox)) goox = ox; if(!sf_getfloat("goz",&goz)) goz = oz; /* GET LOMAX SPECIFIC PARAMETERS */ if(!sf_getint("N",&N)) N = 3; /* Number of control points */ if(!sf_getfloat("TETAMAX",&TETAMAX)) TETAMAX = 1.5; /* Truncation parameter */ if(!sf_getfloat("alpha2",&alpha2)) alpha2 = 4.0; /* Width of gaussian weighting function */ if(!sf_getfloat("freq",&freq)) freq = 100.; /* Pseudo-frequency of waverays */ /* GET DEBUGGING INFO */ if(!sf_getint("prcube",&prcube)) prcube=0; /* For debugging porpouses */ if(!sf_getint("pr",&pr)) pr=0; /* For debugging porpouses */ /* GET SOURCE LOCATIONS */ if(!sf_getint("ns",&ns) || ns==0) ns=1; /* Number of source locations */ if(!sf_getfloat("ds",&ds)) ds=1.; /* interval between sources */ if(!sf_getfloat("os",&os)) os=0.; /* first source location */ if(!sf_getfloat("depth",&depth)) depth=dz; /* Depth location of sources */ pos = (struct point *) sf_alloc (ns,sizeof(struct point)); for(ii=0;ii<ns;ii++) { pos[ii] = makepoint(ii*ds + os, depth); } /* PREPARE OUTPUT */ ampl = sf_output("ampl"); sf_putint(ampl,"n1",gnz); sf_putint(ampl,"n2",gnx); sf_putint(ampl,"n3",ns); sf_putfloat(ampl,"d1",gdz); sf_putfloat(ampl,"d2",gdx); sf_putfloat(ampl,"d3",ds); sf_putfloat(ampl,"o1",goz); sf_putfloat(ampl,"o2",goox); sf_putfloat(ampl,"o3",os); time = sf_output("time"); sf_putint(time,"n1",gnz); sf_putint(time,"n2",gnx); sf_putint(time,"n3",ns); sf_putfloat(time,"d1",gdz); sf_putfloat(time,"d2",gdx); sf_putfloat(time,"d3",ds); sf_putfloat(time,"o1",goz); sf_putfloat(time,"o2",goox); sf_putfloat(time,"o3",os); /* READ VELOCITY MODEL */ vel = sf_floatalloc(nx*nz+2); sf_floatread(vel,nx*nz,inp); /* ALLOCATE MEMORY FOR OUTPUT */ out = (struct grid *) sf_alloc (1,sizeof(struct grid)); out->time = sf_floatalloc (gnx*gnz); out->ampl = sf_floatalloc (gnx*gnz); out->flag = sf_intalloc (gnx*gnz); T = 1. / freq; length = makepoint((nx-1)*dx,(nz-1)*dz); cube = (struct heptagon *) sf_alloc (nrmax,sizeof(struct heptagon)); /* FOR DEBUGGING PORPOUSES, PRINT TO FILE */ if(pr||prcube) { outfile = fopen("junk","w"); } else { outfile = NULL; } /* SET DISPLAY IN ORDER TO SHOW RAYS ON SCREEN */ /* NOTE: THIS PROGRAM USES DIRECT CALLS TO LIB_VPLOT * TO DRAW THE RAYS AND THE WAVEFRONTS */ if(rays || wfront) { setgraphics(ox, oz, length.x, length.z); /* vp_color(BLUE); for(ii=0;ii<gnx;ii++) { vp_umove(ii*gdx+gox, goz); vp_udraw(ii*gdx+gox, (gnz-1)*gdz+goz); } for(ii=0;ii<gnz;ii++) { vp_umove(gox, ii*gdz+goz); vp_udraw((gnx-1)*gdx+gox, ii*gdz+goz); } */ } norsar_init(gnx,gnz, TETAMAX,N,alpha2,inter, nx,nz,ox,oz,dx,dz,length); /* ALGORITHM: * For every source: */ for(ii=0;ii<ns;ii++) { ste = 0; gox = goox + pos[ii].x; sf_warning("\nSource #%d\n", ii); /* 1.- Construct the inital wavefront */ nr = nang; initial (pos[ii], cube, vel, dt, nt, T, lomx, nr, out); gridding_init(gnx,gnz, gdx,gdz,gox,goz, outfile); /* run while the wavefront is not too small */ while (nr > 4) { ste++; /* 2.- Propagate wavefront */ wavefront (cube, nr, vel, dt, nt, T, lomx); if(prcube || pr) { fprintf(outfile,"\n\nwavefront"); printcube(cube, nr, outfile); } /* 3.- Get rid of caustics */ if(first) { if(ste%2==1) { caustics_up (cube, 0, nr); } else { caustics_down (cube, nr-1, nr); } if(prcube || pr) { fprintf(outfile,"\n\ncaustics"); printcube(cube, nr, outfile); } } /* 4.- Eliminate rays that cross boundaries, defined by xmin, xmax, zmin, zmax. Note that the computational grid is a little bigger than the ouput grid. */ xmin = gox-nou*gdx; xmax = 2*pos[ii].x-gox+nou*gdx; zmin = oz-nou*gdz; zmax = length.z+oz+nou*gdz; mark_pts_outofbounds (cube, nr, xmin, xmax, zmin, zmax); if(prcube) { fprintf(outfile, "\n\nboundaries"); printcube(cube, nr, outfile); } /* 5.- Rearrange cube */ makeup(cube, &nr); if(nr<4) break; if(prcube || pr) { fprintf(outfile, "\n\nmakeup"); printcube(cube, nr, outfile); } /* 6.- Calculate amplitudes for new wavefront */ amplitudes (cube, nr); if(prcube) { fprintf(outfile, "\n\namplitudes"); printcube(cube, nr, outfile); } /* 7.- Draw rays */ if(rays) draw_rays (cube, nr); /* 8.- Draw wavefront */ if(wfront && (ste%gap==0)) draw_wavefronts (cube, nr, DSmax); /* 9.- Parameter estimation at receivers */ gridding (cube, nr, out, DSmax, (ste-1)*nt*dt, vel, first); /* pos[ii]); */ /* 10.- Interpolate new points of wavefront */ interpolation (cube, &nr, nrmax, DSmax); /* 0); */ if(prcube) { fprintf(outfile,"\n\ninterpolation"); printcube(cube, nr, outfile); } /* 11.- Prepare to trace new wavefront */ movwavf (cube, nr); if(prcube) { fprintf(outfile,"\n\nmovwavf"); printcube(cube, nr, outfile); } if((wfront || rays) && (ste%gap==0)) vp_erase(); } /* Finally interpolate amplitude and traveltime values to receivers that has not being covered. */ TwoD_interp (out, gnx, gnz); sf_floatwrite(out->time, gnx * gnz, time); sf_floatwrite(out->ampl, gnx * gnz, ampl); } if(pr||prcube) fclose(outfile); exit(0); }
int main() { interpolation(); return 0; }