FiniteVolumeEquation<Vector2D> laplacian(const ScalarFiniteVolumeField &gamma, VectorFiniteVolumeField &phi, Scalar theta) { FiniteVolumeEquation<Vector2D> eqn(phi); const ScalarFiniteVolumeField &gamma0 = gamma.oldField(0); const VectorFiniteVolumeField &phi0 = phi.oldField(0); for (const Cell &cell: phi.cells()) { for (const InteriorLink &nb: cell.neighbours()) { Scalar coeff = gamma(nb.face()) * dot(nb.rCellVec(), nb.outwardNorm()) / nb.rCellVec().magSqr(); Scalar coeff0 = gamma0(nb.face()) * dot(nb.rCellVec(), nb.outwardNorm()) / nb.rCellVec().magSqr(); eqn.add(cell, cell, theta * -coeff); eqn.add(cell, nb.cell(), theta * coeff); eqn.addSource(cell, (1. - theta) * coeff0 * (phi0(nb.cell()) - phi0(cell))); } for (const BoundaryLink &bd: cell.boundaries()) { Scalar coeff = gamma(bd.face()) * dot(bd.rFaceVec(), bd.outwardNorm()) / bd.rFaceVec().magSqr(); Scalar coeff0 = gamma0(bd.face()) * dot(bd.rFaceVec(), bd.outwardNorm()) / bd.rFaceVec().magSqr(); switch (phi.boundaryType(bd.face())) { case VectorFiniteVolumeField::FIXED: eqn.add(cell, cell, theta * -coeff); eqn.addSource(cell, theta * coeff * phi(bd.face())); eqn.addSource(cell, (1. - theta) * coeff0 * (phi0(bd.face()) - phi0(cell))); break; case VectorFiniteVolumeField::NORMAL_GRADIENT: break; case VectorFiniteVolumeField::SYMMETRY: { Vector2D tw = bd.outwardNorm().tangentVec().unitVec(); eqn.add(cell, cell, theta * -coeff); eqn.add(cell, cell, theta * coeff * outer(tw, tw)); eqn.addSource(cell, (1. - theta) * coeff0 * (dot(phi0(cell), tw) * tw - phi0(cell))); } break; default: throw Exception("fv", "laplacian<Vector2D>", "unrecognized or unspecified boundary type."); } } } return eqn; }
/* set v-node state */ void SetVnSt( v_node *v_nodes, c_node * c_nodes, int CodeLength, double *col_one, int NumberCodeBits, double *input_decoder_c) { int i, j; int c_index; for (i=0;i<CodeLength;i++) { *v_nodes[i].initial_value = input_decoder_c[i]; for (j=0;j< *v_nodes[i].degree;j++) { v_nodes[i].index[j]=(int) (col_one[i+j*NumberCodeBits]); for (c_index=0;c_index<*c_nodes[ v_nodes[i].index[j] ].degree;c_index++) if ( c_nodes[ v_nodes[i].index[j] ].index[c_index] == i ) { v_nodes[i].socket[j] = c_index; break; } v_nodes[i].message[j] = phi0( fabs(input_decoder_c[i]) ); if (input_decoder_c[i] < 0) v_nodes[i].sign[j] = 1; else v_nodes[i].sign[j] = 0; } } }
//Hermite void Hermite() { float passot=0.0001,tg,tc,cx,cy; int i=1; Derivata_x_rapp_incr();//calcola la derivata in x dei punti Derivata_y_rapp_incr();//calcola la derivata in y dei punti if(mod_der==1)//checkbox spuntato -> modifico il valore della derivata in un punto { dx[ip]=val_der_x; dy[ip]=val_der_y; } for (tg=0;tg<=1;tg=tg+passot) //nell'intervallo [0,1] disegno punti variando 0.0001 ogni volta { //localizziamo l'intervallo iesimo [t(i),t(i+1)] a cui il valore del parametro tg appartiene //all'inizio i=1,parto quindi dal primo intervallo...ogni volta che supero l'intervallo incremento la i,spostandomi quindi nell'intervallo successivo if (tg>t[i+1]) i++; // mappare il punto tg appartenente all'intervallo [t(i),t(i+1)] in un punto tcappello in [0,1] tc=(tg-t[i])/(t[i+1]-t[i]); // valutiamo le coordinate del punto sulla curva con le formule di interpolazione di hermite cx=Punti[i].x*phi0(tc)+ dx[i]*phi1(tc)*(t[i+1]-t[i])+ Punti[i+1].x*psi0(tc)+ dx[i+1]*psi1(tc)*(t[i+1]-t[i]); cy=Punti[i].y*phi0(tc)+ dy[i]*phi1(tc)*(t[i+1]-t[i])+ Punti[i+1].y*psi0(tc)+ dy[i+1]*psi1(tc)*(t[i+1]-t[i]); //disegno il punto ottenuto sullo schermo glBegin(GL_POINTS); glVertex2f(cx,cy); glEnd(); } glFlush(); }
void Disegna_Funzioni_Base() { float fbasephi0[1000],fbasephi1[1000],fbasepsi0[1000],fbasepsi1[1000],tf,vt[1000]; int n_pti_val=900,i=1; float passo=1.0/(n_pti_val-1); for(tf=0;tf<=1;tf+=passo) { vt[i]=tf; fbasephi0[i]=phi0(tf); fbasephi1[i]=phi1(tf); fbasepsi0[i]=psi0(tf); fbasepsi1[i]=psi1(tf); i++; } //definiamo le coordinate della finestra reale(sul mondo) glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0, 1.0, -0.8, 1.0); //il contenuto della finestra reale prima definita verrà mappato nella viewport sullo schermo che ha origine in (0,500),h 150 e largh 150 glViewport(0,500,150,150); glColor3f(0.0,0.0,1.0); glBegin(GL_POINTS); for(i=1;i<=n_pti_val;i++) glVertex2f(vt[i],fbasephi0[i]); glEnd(); glColor3f(0.0,1.0,1.0); glBegin(GL_POINTS); for(i=1;i<=n_pti_val;i++) glVertex2f(vt[i],fbasephi1[i]); glEnd(); glColor3f(0.0,1.0,0.0); glBegin(GL_POINTS); for(i=1;i<=n_pti_val;i++) glVertex2f(vt[i],fbasepsi0[i]); glEnd(); glColor3f(1.0,0.0,0.0); glBegin(GL_POINTS); for(i=1;i<=n_pti_val;i++) glVertex2f(vt[i],fbasepsi1[i]); glEnd(); glFlush(); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0, WINH, 0.0, WINH); glViewport(0,0,WINH,WINH); }
model_error_case() : acc_(2) , model_() { Eigen::VectorXd phi0(2), veps(2); Eigen::MatrixXd phi1(2,2); phi0 << 2, 3; phi1 << .80, 0, 0, .64; veps << 1.0, 0.25; model_ = alps::alea::util::var1_model<double>(phi0, phi1, veps); }
Vector7d manipulablityG(const Vector7d& phi, const double m0, const double ks) { const double h = 0.0000001; Vector7d tau; Vector7d phi0; Vector7d phi1; for (unsigned int i = 0; i < 7; i++) { phi0 = phi1 = phi; phi0(i) -= h; phi1(i) += h; tau(i) = (manipulablityV(phi1, m0, ks) - manipulablityV(phi0, m0, ks))/(2.0*h); } return tau; }
alps::alea::util::var1_model<double> get_test_model() { // Model setup Eigen::VectorXd phi0(2), veps(2); Eigen::MatrixXd phi1(2,2); phi0 << 2, 3; phi1 << .5, .25, .25, .3; veps << 1.0, 0.25; std::cerr << "PHI0=\n" << phi0 << "\nPHI1=\n" << phi1 << "\nVEPS=\n" << veps << "\n"; return alps::alea::util::var1_model<double>(phi0, phi1, veps); }
Field<dim> lbfgs( const Functional& F, const Gradient& dF, const Field<dim>& phi_start, const unsigned int m, const double eps ) { double cost_old = std::numeric_limits<double>::infinity(); double cost = F(phi_start); Field<dim> phi0(phi_start); DualField<dim> df0 = dF(phi_start); const auto& discretization = phi0.get_discretization(); // Create vectors for storing the last few differences of the guesses, // differences of the gradients, and the inverses of their inner products std::vector<Field<dim>> s(m, Field<dim>(discretization)); std::vector<DualField<dim>> y(m, DualField<dim>(discretization)); std::vector<double> rho(m); // As an initial guess, we will assume that the Hessian inverse is a // multiple of the inverse of the mass matrix double gamma = 1.0; for (unsigned int k = 0; std::abs(cost_old - cost)/cost > eps; ++k) { const Field<dim> p = -lbfgs_two_loop(df0, s, y, rho, gamma); const Field<dim> phi1 = line_search(F, phi0, df0, p, eps); const DualField<dim> df1 = dF(phi1); s[0] = phi1 - phi0; y[0] = df1 - df0; const double cos_angle = inner_product(y[0], s[0]); const double norm_y = norm(y[0]); rho[0] = 1.0 / cos_angle; gamma = cos_angle / (norm_y * norm_y); std::rotate(s.begin(), s.begin() + 1, s.end()); std::rotate(y.begin(), y.begin() + 1, y.end()); std::rotate(rho.begin(), rho.begin() + 1, rho.end()); phi0 = phi1; df0 = df1; cost_old = cost; cost = F(phi0); } return phi0; }
TEST(var1_test, autocorr) { Eigen::VectorXd phi0(2), veps(2); Eigen::MatrixXd phi1(2,2); phi0 << 2, 3; phi1 << .80, 0, 0, .64; veps << 1.0, 0.25; alps::alea::util::var1_model<double> model(phi0, phi1, veps); std::cerr << "EXACT MEAN=" << model.mean().transpose() << "\n"; std::cerr << "EXACT TAU =" << model.ctau().diagonal().transpose() << "\n"; alps::alea::autocorr_acc<double> acc(2); fill(model, acc, 400000); alps::alea::autocorr_result<double> res = acc.finalize(); print_result(std::cerr, res); // perform T2 test alps::alea::t2_result t2 = alps::alea::test_mean(res, model.mean()); print_t2(std::cerr, t2); ASSERT_GE(t2.pvalue(), 0.01); }
TEST(var1_test, same) { Eigen::VectorXd phi0(2), veps_one(2), veps_two(2); Eigen::MatrixXd phi1(2,2); phi0 << 2, 3; phi1 << .90, 0, 0, .30; veps_one << 1.0, 0.25; veps_two << 2.0, 3.25; alps::alea::util::var1_model<double> model1(phi0, phi1, veps_one); alps::alea::util::var1_model<double> model2(phi0, phi1, veps_two); std::cerr << "EXACT MEAN=" << model1.mean().transpose() << "\n"; alps::alea::autocorr_acc<double> acc1(2), acc2(2); fill(model1, acc1, 400000); fill(model2, acc2, 400000); alps::alea::autocorr_result<double> res1 = acc1.finalize(); print_result(std::cerr, res1); alps::alea::autocorr_result<double> res2 = acc2.finalize(); print_result(std::cerr, res2); // perform T2 test manually alps::alea::var_result<double> diff = alps::alea::internal::pool_var(res1, res2); print_result(std::cerr, diff); alps::alea::t2_result t2 = alps::alea::t2_test(diff.mean(), diff.var(), diff.observations(), 1, 1e-10); print_t2(std::cerr, t2); ASSERT_GE(t2.pvalue(), 0.01); // Perform T2 test automatically t2 = alps::alea::test_mean(res1, res2); ASSERT_GE(t2.pvalue(), 0.01); }
kinematicSingleLayer::kinematicSingleLayer ( const word& modelType, const fvMesh& mesh, const dimensionedVector& g, const word& regionType, const bool readFields ) : surfaceFilmModel(modelType, mesh, g, regionType), momentumPredictor_(solution().subDict("PISO").lookup("momentumPredictor")), nOuterCorr_(solution().subDict("PISO").lookupOrDefault("nOuterCorr", 1)), nCorr_(readLabel(solution().subDict("PISO").lookup("nCorr"))), nNonOrthCorr_ ( readLabel(solution().subDict("PISO").lookup("nNonOrthCorr")) ), cumulativeContErr_(0.0), deltaSmall_("deltaSmall", dimLength, SMALL), deltaCoLimit_(solution().lookupOrDefault("deltaCoLimit", 1e-4)), rho_ ( IOobject ( "rhof", time().timeName(), regionMesh(), IOobject::NO_READ, IOobject::AUTO_WRITE ), regionMesh(), dimensionedScalar("zero", dimDensity, 0.0), zeroGradientFvPatchScalarField::typeName ), mu_ ( IOobject ( "muf", time().timeName(), regionMesh(), IOobject::NO_READ, IOobject::AUTO_WRITE ), regionMesh(), dimensionedScalar("zero", dimPressure*dimTime, 0.0), zeroGradientFvPatchScalarField::typeName ), sigma_ ( IOobject ( "sigmaf", time().timeName(), regionMesh(), IOobject::NO_READ, IOobject::AUTO_WRITE ), regionMesh(), dimensionedScalar("zero", dimMass/sqr(dimTime), 0.0), zeroGradientFvPatchScalarField::typeName ), delta_ ( IOobject ( "deltaf", time().timeName(), regionMesh(), IOobject::MUST_READ, IOobject::AUTO_WRITE ), regionMesh() ), alpha_ ( IOobject ( "alpha", time().timeName(), regionMesh(), IOobject::READ_IF_PRESENT, IOobject::AUTO_WRITE ), regionMesh(), dimensionedScalar("zero", dimless, 0.0), zeroGradientFvPatchScalarField::typeName ), U_ ( IOobject ( "Uf", time().timeName(), regionMesh(), IOobject::MUST_READ, IOobject::AUTO_WRITE ), regionMesh() ), Us_ ( IOobject ( "Usf", time().timeName(), regionMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), U_, zeroGradientFvPatchScalarField::typeName ), Uw_ ( IOobject ( "Uwf", time().timeName(), regionMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), U_, zeroGradientFvPatchScalarField::typeName ), deltaRho_ ( IOobject ( delta_.name() + "*" + rho_.name(), time().timeName(), regionMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), regionMesh(), dimensionedScalar("zero", delta_.dimensions()*rho_.dimensions(), 0.0), zeroGradientFvPatchScalarField::typeName ), phi_ ( IOobject ( "phi", time().timeName(), regionMesh(), IOobject::NO_READ, IOobject::AUTO_WRITE ), regionMesh(), dimensionedScalar("0", dimLength*dimMass/dimTime, 0.0) ), primaryMassTrans_ ( IOobject ( "primaryMassTrans", time().timeName(), regionMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), regionMesh(), dimensionedScalar("zero", dimMass, 0.0), zeroGradientFvPatchScalarField::typeName ), cloudMassTrans_ ( IOobject ( "cloudMassTrans", time().timeName(), regionMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), regionMesh(), dimensionedScalar("zero", dimMass, 0.0), zeroGradientFvPatchScalarField::typeName ), cloudDiameterTrans_ ( IOobject ( "cloudDiameterTrans", time().timeName(), regionMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), regionMesh(), dimensionedScalar("zero", dimLength, -1.0), zeroGradientFvPatchScalarField::typeName ), USp_ ( IOobject ( "USpf", time().timeName(), regionMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), regionMesh(), dimensionedVector ( "zero", dimMass*dimVelocity/dimArea/dimTime, Zero ), this->mappedPushedFieldPatchTypes<vector>() ), pSp_ ( IOobject ( "pSpf", time_.timeName(), regionMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), regionMesh(), dimensionedScalar("zero", dimPressure, 0.0), this->mappedPushedFieldPatchTypes<scalar>() ), rhoSp_ ( IOobject ( "rhoSpf", time_.timeName(), regionMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), regionMesh(), dimensionedScalar("zero", dimMass/dimTime/dimArea, 0.0), this->mappedPushedFieldPatchTypes<scalar>() ), USpPrimary_ ( IOobject ( USp_.name(), // must have same name as USp_ to enable mapping time().timeName(), primaryMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), primaryMesh(), dimensionedVector("zero", USp_.dimensions(), Zero) ), pSpPrimary_ ( IOobject ( pSp_.name(), // must have same name as pSp_ to enable mapping time().timeName(), primaryMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), primaryMesh(), dimensionedScalar("zero", pSp_.dimensions(), 0.0) ), rhoSpPrimary_ ( IOobject ( rhoSp_.name(), // must have same name as rhoSp_ to enable mapping time().timeName(), primaryMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), primaryMesh(), dimensionedScalar("zero", rhoSp_.dimensions(), 0.0) ), UPrimary_ ( IOobject ( "U", // must have same name as U to enable mapping time().timeName(), regionMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), regionMesh(), dimensionedVector("zero", dimVelocity, Zero), this->mappedFieldAndInternalPatchTypes<vector>() ), pPrimary_ ( IOobject ( "p", // must have same name as p to enable mapping time().timeName(), regionMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), regionMesh(), dimensionedScalar("zero", dimPressure, 0.0), this->mappedFieldAndInternalPatchTypes<scalar>() ), rhoPrimary_ ( IOobject ( "rho", // must have same name as rho to enable mapping time().timeName(), regionMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), regionMesh(), dimensionedScalar("zero", dimDensity, 0.0), this->mappedFieldAndInternalPatchTypes<scalar>() ), muPrimary_ ( IOobject ( "thermo:mu", // must have same name as mu to enable mapping time().timeName(), regionMesh(), IOobject::NO_READ, IOobject::NO_WRITE ), regionMesh(), dimensionedScalar("zero", dimPressure*dimTime, 0.0), this->mappedFieldAndInternalPatchTypes<scalar>() ), filmThermo_(filmThermoModel::New(*this, coeffs_)), availableMass_(regionMesh().nCells(), 0.0), injection_(*this, coeffs_), transfer_(*this, coeffs_), turbulence_(filmTurbulenceModel::New(*this, coeffs_)), forces_(*this, coeffs_), addedMassTotal_(0.0) { if (readFields) { transferPrimaryRegionThermoFields(); correctAlpha(); correctThermoFields(); deltaRho_ == delta_*rho_; surfaceScalarField phi0 ( IOobject ( "phi", time().timeName(), regionMesh(), IOobject::READ_IF_PRESENT, IOobject::AUTO_WRITE, false ), fvc::flux(deltaRho_*U_) ); phi_ == phi0; } }