void QCanvas::razor_CB(QPointF A, QPointF B, bool time_sleep) { double t0 = 0; double t1 = 1; size_t size = obj_Polyhedrons.size(); QPoint vec1(obj_Polyhedrons.value(0).F.x() - obj_Polyhedrons.value(0).S.x(),obj_Polyhedrons.value(0).F.y() - obj_Polyhedrons.value(0).S.y()); QPoint vec2(obj_Polyhedrons.value(1).F.x() - obj_Polyhedrons.value(0).S.x(),obj_Polyhedrons.value(1).F.y() - obj_Polyhedrons.value(0).S.y()); ssize_t koef = ((vec1.x()*vec2.y() - vec1.y()*vec2.x()) > 0) ? (1):(-1); QPoint D (B.x() - A.x(),B.y() - A.y()); bool flag = 1; for(size_t i = 0; i<size; ++i) { double t = 0; QPoint w (A.x() - obj_Polyhedrons.value(i).F.x(), A.y() - obj_Polyhedrons.value(i).F.y()); QPoint N (koef*(obj_Polyhedrons.value(i).S.y() - obj_Polyhedrons.value(i).F.y()),koef*(obj_Polyhedrons.value(i).F.x() - obj_Polyhedrons.value(i).S.x())); double Q = scalar(w,N); double P = scalar(D,N); if(P == 0) { if(Q<0) { flag = 0; break; } } else { t = - Q/P; if(P>0) { if(t>1) { flag = 0; break; } else if(t>t0) t0 = t; } else { if(t<0) { flag = 0; break; } else if(t<t1) t1 = t; } } } if (t0<=t1 && flag) Add_lines(QPointF( A.x()+(B.x()-A.x())*t0 , A.y()+(B.y()-A.y())*t0), QPointF( A.x()+(B.x()-A.x())*t1 , A.y()+(B.y()-A.y())*t1), Qt::blue); }
QueryContext::QueryContext(const serialization::QueryContext &proto, const CatalogDatabaseLite &database, StorageManager *storage_manager, const tmb::client_id scheduler_client_id, tmb::MessageBus *bus) { DCHECK(ProtoIsValid(proto, database)) << "Attempted to create QueryContext from an invalid proto description:\n" << proto.DebugString(); for (int i = 0; i < proto.aggregation_states_size(); ++i) { PartitionedAggregationOperationStates partitioned_aggregation_states; const serialization::QueryContext::AggregationOperationStateContext &aggr_state_context_proto = proto.aggregation_states(i); for (std::uint64_t j = 0; j < aggr_state_context_proto.num_partitions(); ++j) { partitioned_aggregation_states.emplace_back( AggregationOperationState::ReconstructFromProto(aggr_state_context_proto.aggregation_state(), database, storage_manager)); } aggregation_states_.push_back(move(partitioned_aggregation_states)); } for (int i = 0; i < proto.generator_functions_size(); ++i) { const GeneratorFunctionHandle *func_handle = GeneratorFunctionFactory::Instance().reconstructFromProto(proto.generator_functions(i)); DCHECK(func_handle != nullptr); generator_functions_.emplace_back( std::unique_ptr<const GeneratorFunctionHandle>(func_handle)); } for (int i = 0; i < proto.join_hash_tables_size(); ++i) { PartitionedJoinHashTables partitioned_join_hash_tables; const serialization::QueryContext::HashTableContext &hash_table_context_proto = proto.join_hash_tables(i); for (std::uint64_t j = 0; j < hash_table_context_proto.num_partitions(); ++j) { partitioned_join_hash_tables.emplace_back( JoinHashTableFactory::CreateResizableFromProto(hash_table_context_proto.join_hash_table(), storage_manager)); } join_hash_tables_.push_back(move(partitioned_join_hash_tables)); } for (int i = 0; i < proto.insert_destinations_size(); ++i) { const serialization::InsertDestination &insert_destination_proto = proto.insert_destinations(i); insert_destinations_.emplace_back(InsertDestination::ReconstructFromProto( proto.query_id(), insert_destination_proto, database.getRelationSchemaById(insert_destination_proto.relation_id()), storage_manager, scheduler_client_id, bus)); } for (int i = 0; i < proto.lip_filters_size(); ++i) { lip_filters_.emplace_back( std::unique_ptr<LIPFilter>( LIPFilterFactory::ReconstructFromProto(proto.lip_filters(i)))); } for (int i = 0; i < proto.lip_filter_deployments_size(); ++i) { lip_deployments_.emplace_back( std::make_unique<LIPFilterDeployment>( proto.lip_filter_deployments(i), lip_filters_)); } for (int i = 0; i < proto.predicates_size(); ++i) { predicates_.emplace_back( PredicateFactory::ReconstructFromProto(proto.predicates(i), database)); } for (int i = 0; i < proto.scalar_groups_size(); ++i) { vector<unique_ptr<const Scalar>> scalar_group; const serialization::QueryContext::ScalarGroup &scalar_group_proto = proto.scalar_groups(i); for (int j = 0; j < scalar_group_proto.scalars_size(); ++j) { scalar_group.emplace_back( ScalarFactory::ReconstructFromProto(scalar_group_proto.scalars(j), database)); } scalar_groups_.push_back(move(scalar_group)); } for (int i = 0; i < proto.sort_configs_size(); ++i) { sort_configs_.emplace_back( SortConfiguration::ReconstructFromProto(proto.sort_configs(i), database)); } for (int i = 0; i < proto.tuples_size(); ++i) { tuples_.emplace_back(Tuple::ReconstructFromProto(proto.tuples(i))); } for (int i = 0; i < proto.update_groups_size(); ++i) { const serialization::QueryContext::UpdateGroup &update_group_proto = proto.update_groups(i); std::unordered_map<attribute_id, std::unique_ptr<const Scalar>> update_group; for (int j = 0; j < update_group_proto.update_assignments_size(); ++j) { const serialization::QueryContext::UpdateGroup::UpdateAssignment &update_assignment_proto = update_group_proto.update_assignments(j); unique_ptr<const Scalar> scalar( ScalarFactory::ReconstructFromProto(update_assignment_proto.scalar(), database)); update_group.emplace(update_assignment_proto.attribute_id(), move(scalar)); } update_groups_.push_back(move(update_group)); } for (int i = 0; i < proto.window_aggregation_states_size(); ++i) { window_aggregation_states_.emplace_back( WindowAggregationOperationState::ReconstructFromProto(proto.window_aggregation_states(i), database, storage_manager)); } }
int main(int argc, char *argv[]) { # include "setRootCase.H" # include "createTime.H" # include "createDynamicFvMesh.H" # include "createFields.H" # include "initContinuityErrs.H" // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // Info << "\nStarting time loop\n" << endl; for (runTime++; !runTime.end(); runTime++) { Info << "Time = " << runTime.value() << endl << endl; # include "readPISOControls.H" interface.moveMeshPointsForOldFreeSurfDisplacement(); interface.updateDisplacementDirections(); interface.predictPoints(); Info<< "\nMax surface Courant Number = " << interface.maxCourantNumber() << endl << endl; for (int corr=0; corr<nOuterCorr; corr++) { // Update interface bc interface.updateBoundaryConditions(); // Make the fluxes relative phi -= fvc::meshPhi(rho, U); # include "CourantNo.H" fvVectorMatrix UEqn ( fvm::ddt(rho, U) + fvm::div(fvc::interpolate(rho)*phi, U, "div(phi,U)") - fvm::laplacian(mu, U) ); solve(UEqn == -fvc::grad(p)); // --- PISO loop for (int i=0; i<nCorr; i++) { volScalarField AU = UEqn.A(); U = UEqn.H()/AU; phi = (fvc::interpolate(U) & mesh.Sf()); # include "scalePhi.H" // Non-orthogonal pressure corrector loop for (label nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++) { fvScalarMatrix pEqn ( fvm::laplacian(1.0/AU, p) == fvc::div(phi) ); # include "setReference.H" pEqn.solve(); if (nonOrth == nNonOrthCorr) { phi -= pEqn.flux(); } } # include "continuityErrs.H" // Momentum corrector U -= fvc::grad(p)/AU; U.correctBoundaryConditions(); } interface.correctPoints(); # include "freeSurfaceContinuityErrs.H" } # include "volContinuity.H" Info << "Total surface tension force: " << interface.totalSurfaceTensionForce() << endl; vector totalForce = interface.totalViscousForce() + interface.totalPressureForce(); Info << "Total force: " << totalForce << endl; runTime.write(); Info << "ExecutionTime = " << scalar(runTime.elapsedCpuTime()) << " s\n" << endl << endl; } Info << "End\n" << endl; return(0); }
void realizableKE::correct() { // Bound in case of topological change // HJ, 22/Aug/2007 if (mesh_.changing()) { bound(k_, k0_); bound(epsilon_, epsilon0_); } RASModel::correct(); if (!turbulence_) { return; } volTensorField gradU = fvc::grad(U_); volScalarField S2 = 2*magSqr(dev(symm(gradU))); volScalarField magS = sqrt(S2); volScalarField eta = magS*k_/epsilon_; volScalarField C1 = max(eta/(scalar(5) + eta), scalar(0.43)); volScalarField G("RASModel::G", nut_*S2); // Update epsilon and G at the wall epsilon_.boundaryField().updateCoeffs(); // Dissipation equation tmp<fvScalarMatrix> epsEqn ( fvm::ddt(epsilon_) + fvm::div(phi_, epsilon_) + fvm::SuSp(-fvc::div(phi_), epsilon_) - fvm::laplacian(DepsilonEff(), epsilon_) == C1*magS*epsilon_ - fvm::Sp ( C2_*epsilon_/(k_ + sqrt(nu()*epsilon_)), epsilon_ ) ); epsEqn().relax(); epsEqn().boundaryManipulate(epsilon_.boundaryField()); solve(epsEqn); bound(epsilon_, epsilon0_); // Turbulent kinetic energy equation tmp<fvScalarMatrix> kEqn ( fvm::ddt(k_) + fvm::div(phi_, k_) + fvm::SuSp(-fvc::div(phi_), k_) - fvm::laplacian(DkEff(), k_) == G - fvm::Sp(epsilon_/k_, k_) ); kEqn().relax(); solve(kEqn); bound(k_, k0_); // Re-calculate viscosity nut_ = rCmu(gradU, S2, magS)*sqr(k_)/epsilon_; nut_.correctBoundaryConditions(); }
Foam::SVD::SVD(const scalarRectangularMatrix& A, const scalar minCondition) : U_(A), V_(A.m(), A.m()), S_(A.m()), VSinvUt_(A.m(), A.n()), nZeros_(0) { // SVDcomp to find U_, V_ and S_ - the singular values const label Um = U_.m(); const label Un = U_.n(); scalarList rv1(Um); scalar g = 0; scalar scale = 0; scalar s = 0; scalar anorm = 0; label l = 0; for (label i = 0; i < Um; i++) { l = i+2; rv1[i] = scale*g; g = s = scale = 0; if (i < Un) { for (label k = i; k < Un; k++) { scale += mag(U_[k][i]); } if (scale != 0) { for (label k = i; k < Un; k++) { U_[k][i] /= scale; s += U_[k][i]*U_[k][i]; } scalar f = U_[i][i]; g = -sign(Foam::sqrt(s), f); scalar h = f*g - s; U_[i][i] = f - g; for (label j = l-1; j < Um; j++) { s = 0; for (label k = i; k < Un; k++) { s += U_[k][i]*U_[k][j]; } f = s/h; for (label k = i; k < A.n(); k++) { U_[k][j] += f*U_[k][i]; } } for (label k = i; k < Un; k++) { U_[k][i] *= scale; } } } S_[i] = scale*g; g = s = scale = 0; if (i+1 <= Un && i != Um) { for (label k = l-1; k < Um; k++) { scale += mag(U_[i][k]); } if (scale != 0) { for (label k=l-1; k < Um; k++) { U_[i][k] /= scale; s += U_[i][k]*U_[i][k]; } scalar f = U_[i][l-1]; g = -sign(Foam::sqrt(s),f); scalar h = f*g - s; U_[i][l-1] = f - g; for (label k = l-1; k < Um; k++) { rv1[k] = U_[i][k]/h; } for (label j = l-1; j < Un; j++) { s = 0; for (label k = l-1; k < Um; k++) { s += U_[j][k]*U_[i][k]; } for (label k = l-1; k < Um; k++) { U_[j][k] += s*rv1[k]; } } for (label k = l-1; k < Um; k++) { U_[i][k] *= scale; } } } anorm = max(anorm, mag(S_[i]) + mag(rv1[i])); } for (label i = Um-1; i >= 0; i--) { if (i < Um-1) { if (g != 0) { for (label j = l; j < Um; j++) { V_[j][i] = (U_[i][j]/U_[i][l])/g; } for (label j=l; j < Um; j++) { s = 0; for (label k = l; k < Um; k++) { s += U_[i][k]*V_[k][j]; } for (label k = l; k < Um; k++) { V_[k][j] += s*V_[k][i]; } } } for (label j = l; j < Um; j++) { V_[i][j] = V_[j][i] = 0.0; } } V_[i][i] = 1; g = rv1[i]; l = i; } for (label i = min(Um, Un) - 1; i >= 0; i--) { l = i+1; g = S_[i]; for (label j = l; j < Um; j++) { U_[i][j] = 0.0; } if (g != 0) { g = 1.0/g; for (label j = l; j < Um; j++) { s = 0; for (label k = l; k < Un; k++) { s += U_[k][i]*U_[k][j]; } scalar f = (s/U_[i][i])*g; for (label k = i; k < Un; k++) { U_[k][j] += f*U_[k][i]; } } for (label j = i; j < Un; j++) { U_[j][i] *= g; } } else { for (label j = i; j < Un; j++) { U_[j][i] = 0.0; } } ++U_[i][i]; } for (label k = Um-1; k >= 0; k--) { for (label its = 0; its < 35; its++) { bool flag = true; label nm; for (l = k; l >= 0; l--) { nm = l-1; if (mag(rv1[l]) + anorm == anorm) { flag = false; break; } if (mag(S_[nm]) + anorm == anorm) break; } if (flag) { scalar c = 0.0; s = 1.0; for (label i = l; i < k+1; i++) { scalar f = s*rv1[i]; rv1[i] = c*rv1[i]; if (mag(f) + anorm == anorm) break; g = S_[i]; scalar h = sqrtSumSqr(f, g); S_[i] = h; h = 1.0/h; c = g*h; s = -f*h; for (label j = 0; j < Un; j++) { scalar y = U_[j][nm]; scalar z = U_[j][i]; U_[j][nm] = y*c + z*s; U_[j][i] = z*c - y*s; } } } scalar z = S_[k]; if (l == k) { if (z < 0.0) { S_[k] = -z; for (label j = 0; j < Um; j++) V_[j][k] = -V_[j][k]; } break; } if (its == 34) { WarningIn ( "SVD::SVD" "(scalarRectangularMatrix& A, const scalar minCondition)" ) << "no convergence in 35 SVD iterations" << endl; } scalar x = S_[l]; nm = k-1; scalar y = S_[nm]; g = rv1[nm]; scalar h = rv1[k]; scalar f = ((y - z)*(y + z) + (g - h)*(g + h))/(2.0*h*y); g = sqrtSumSqr(f, scalar(1)); f = ((x - z)*(x + z) + h*((y/(f + sign(g, f))) - h))/x; scalar c = 1.0; s = 1.0; for (label j = l; j <= nm; j++) { label i = j + 1; g = rv1[i]; y = S_[i]; h = s*g; g = c*g; scalar z = sqrtSumSqr(f, h); rv1[j] = z; c = f/z; s = h/z; f = x*c + g*s; g = g*c - x*s; h = y*s; y *= c; for (label jj = 0; jj < Um; jj++) { x = V_[jj][j]; z = V_[jj][i]; V_[jj][j] = x*c + z*s; V_[jj][i] = z*c - x*s; } z = sqrtSumSqr(f, h); S_[j] = z; if (z) { z = 1.0/z; c = f*z; s = h*z; } f = c*g + s*y; x = c*y - s*g; for (label jj=0; jj < Un; jj++) { y = U_[jj][j]; z = U_[jj][i]; U_[jj][j] = y*c + z*s; U_[jj][i] = z*c - y*s; } } rv1[l] = 0.0; rv1[k] = f; S_[k] = x; } } // zero singular values that are less than minCondition*maxS const scalar minS = minCondition*S_[findMax(S_)]; forAll(S_, i) { if (S_[i] <= minS) { //Info<< "Removing " << S_[i] << " < " << minS << endl; S_[i] = 0; nZeros_++; } } // now multiply out to find the pseudo inverse of A, VSinvUt_ multiply(VSinvUt_, V_, inv(S_), U_.T()); // test SVD /*scalarRectangularMatrix SVDA(A.n(), A.m()); multiply(SVDA, U_, S_, transpose(V_)); scalar maxDiff = 0; scalar diff = 0; for (label i = 0; i < A.n(); i++) { for (label j = 0; j < A.m(); j++) { diff = mag(A[i][j] - SVDA[i][j]); if (diff > maxDiff) maxDiff = diff; } } Info<< "Maximum discrepancy between A and svd(A) = " << maxDiff << endl; if (maxDiff > 4) { Info<< "singular values " << S_ << endl; } */ }
/** Function to calculate wall distance and phi0(dist). Called by \ref calc_angledist_force */ static double calc_angledist_param(Particle *p_mid, Particle *p_left, Particle *p_right, Bonded_ia_parameters *iaparams) { double cosine=0.0, vec1[3], vec2[3], d1i=0.0, d2i=0.0, dist1=0.0, dist2=0.0, phi0=0.0; // double pwdist=0.0, pwdist0=0.0, pwdist1=0.0; double normal, folded_pos[3], phimn=0.0, distmn=0.0, phimx=0.0, distmx=0.0, drange=0.0; double pwdist[n_constraints],pwdistmin=0.0; Constraint_wall wall; int j, k; int img[3]; wall.d = 0; /* vector from p_left to p_mid */ get_mi_vector(vec1, p_mid->r.p, p_left->r.p); dist1 = sqrlen(vec1); d1i = 1.0 / sqrt(dist1); for(j=0;j<3;j++) vec1[j] *= d1i; /* vector from p_mid to p_right */ get_mi_vector(vec2, p_right->r.p, p_mid->r.p); dist2 = sqrlen(vec2); d2i = 1.0 / sqrt(dist2); for(j=0;j<3;j++) vec2[j] *= d2i; /* vectors are normalised so cosine is just cos(angle_between_vec1_and_vec2) */ cosine = scalar(vec1, vec2); if ( cosine > TINY_COS_VALUE) cosine = TINY_COS_VALUE; if ( cosine < -TINY_COS_VALUE) cosine = -TINY_COS_VALUE; // fac = iaparams->p.angledist.bend; /* spring constant from .tcl file */ phimn = iaparams->p.angledist.phimin; distmn = iaparams->p.angledist.distmin; phimx = iaparams->p.angledist.phimax; distmx = iaparams->p.angledist.distmax; /* folds coordinates of p_mid into original box */ memcpy(folded_pos, p_mid->r.p, 3*sizeof(double)); memcpy(img, p_mid->l.i, 3*sizeof(int)); fold_position(folded_pos, img); /* Calculates distance between p_mid and constraint */ for(k=0;k<n_constraints;k++) { pwdist[k]=0.0; } for(k=0;k<n_constraints;k++) { switch(constraints[k].type) { case CONSTRAINT_WAL: /* dist is distance of wall from origin */ wall=constraints[k].c.wal; /* check that constraint vector is normalised */ normal=0.0; for(j=0;j<3;j++) normal += wall.n[j] * wall.n[j]; if (sqrt(normal) != 1.0) { for(j=0;j<3;j++) wall.n[j]=wall.n[j]/normal; } /* pwdist is distance of wall from p_mid */ pwdist[k]=-1.0 * constraints[k].c.wal.d; for(j=0;j<3;j++) { pwdist[k] += folded_pos[j] * constraints[k].c.wal.n[j]; } if (k==0) { pwdistmin=pwdist[k]; } if (pwdist[k] <= pwdistmin) { pwdistmin = pwdist[k]; } break; } } /*get phi0(z)*/ if (pwdistmin <= distmn) { phi0 = phimn; // fprintf(stdout,"\nIn angledist_set_params: z_p_mid=%f pwdistmin=%f distmn=%f ",folded_pos[2],pwdistmin,distmn); // fprintf(stdout," phi0=%f\n",phi0*180.0/PI); } else if (pwdistmin >= distmx && pwdistmin <= box_l[2]-wall.d-distmx) { phi0 = phimx; } else { drange = (pwdistmin-distmn)*PI/(distmx-distmn); phi0 = ((cos(drange-PI)+1.0)*(phimx-phimn))*0.5+phimn; // fprintf(stdout,"\nIn angledist_set_params: z_p_mid=%f pwdistmin=%f box_lz/2=%f ",folded_pos[2],pwdistmin,box_l[2]/2.0); // fprintf(stdout," phi0=%f\n",phi0*180.0/PI); } return phi0; }
Foam::PatchInjection<CloudType>::PatchInjection ( const dictionary& dict, CloudType& owner ) : InjectionModel<CloudType>(dict, owner, typeName), patchName_(this->coeffDict().lookup("patchName")), duration_(readScalar(this->coeffDict().lookup("duration"))), parcelsPerSecond_ ( readScalar(this->coeffDict().lookup("parcelsPerSecond")) ), U0_(this->coeffDict().lookup("U0")), volumeFlowRate_ ( DataEntry<scalar>::New ( "volumeFlowRate", this->coeffDict() ) ), parcelPDF_ ( pdfs::pdf::New ( this->coeffDict().subDict("parcelPDF"), owner.rndGen() ) ), cellOwners_(), fraction_(1.0) { label patchId = owner.mesh().boundaryMesh().findPatchID(patchName_); if (patchId < 0) { FatalErrorIn ( "PatchInjection<CloudType>::PatchInjection" "(" "const dictionary&, " "CloudType&" ")" ) << "Requested patch " << patchName_ << " not found" << nl << "Available patches are: " << owner.mesh().boundaryMesh().names() << nl << exit(FatalError); } const polyPatch& patch = owner.mesh().boundaryMesh()[patchId]; cellOwners_ = patch.faceCells(); label patchSize = cellOwners_.size(); label totalPatchSize = patchSize; reduce(totalPatchSize, sumOp<label>()); fraction_ = scalar(patchSize)/totalPatchSize; // Set total volume/mass to inject this->volumeTotal_ = fraction_*volumeFlowRate_().integrate(0.0, duration_); this->massTotal_ *= fraction_; }
float ObjectEdgeDetectorCPU::scalarAndFlip(FixedColVector<float,4> &a, FixedColVector<float,4> &b){ return flipAngle(scalar(a,b)); }
void EulerianParticleVelocityForce ( cfdemCloud& sm, const fvMesh& mesh, volVectorField& Uf_, volVectorField& Up_, volScalarField& rho_, volScalarField& alpf_, volScalarField& Pg_, volVectorField& MappedDragForce_, const labelListList& particleList_, const bool& weighting_ ) { // Neighbouring cells CPCCellToCellStencil neighbourCells(mesh); // get viscosity field #ifdef comp const volScalarField nufField = sm.turbulence().mu()/rho_; #else const volScalarField& nufField = sm.turbulence().nu(); #endif // Gas pressure gradient volVectorField gradPg_ = fvc::grad(Pg_); interpolationCellPoint<vector> gradPgInterpolator_(gradPg_); // Local variables label cellID(-1); vector drag(0,0,0); vector Ufluid(0,0,0); vector position(0,0,0); scalar voidfraction(1); vector Up(0,0,0); vector Ur(0,0,0); scalar ds(0); scalar nuf(0); scalar rhof(0); vector WenYuDrag(0,0,0); interpolationCellPoint<scalar> voidfractionInterpolator_(alpf_); interpolationCellPoint<vector> UInterpolator_(Uf_); scalar dist_s(0); scalar sumWeights(0); scalarField weightScalar(27,scalar(0.0)); Field <Field <scalar> > particleWeights(particleList_.size(),weightScalar); //Info << " particle size " << particleList_.size() << endl; // Number of particle in a cell scalarField np(mesh.cells().size(),scalar(0)); // Particle volume scalar Volp(0); vector gradPg_int(0,0,0); for(int ii = 0; ii < particleList_.size(); ii++) { int index = particleList_[ii][0]; cellID = sm.cellIDs()[index][0]; position = sm.position(index); Ufluid = UInterpolator_.interpolate(position,cellID); Up = sm.velocity(index); Ur = Ufluid-Up; ds = 2*sm.radius(index); // Calculate WenYu Drag voidfraction = voidfractionInterpolator_.interpolate(position,cellID); nuf = nufField[cellID]; rhof = rho_[cellID]; WenYuDragForce(Ur,ds,rhof,nuf,voidfraction,WenYuDrag); Volp = ds*ds*ds*M_PI/6; gradPg_int = gradPgInterpolator_.interpolate(position,cellID); //if (cellID > -1) // particle centre is in domain //{ if(weighting_) { labelList& cellsNeigh = neighbourCells[cellID]; sumWeights = 0; dist_s = 0; //Info << " index = " << index << " ii = " << ii << " cellID = " << cellID << endl; forAll(cellsNeigh,jj) { // Find distances between particle and neighbouring cells dist_s = mag(sm.mesh().C()[cellsNeigh[jj]]-position)/pow(sm.mesh().V()[cellsNeigh[jj]],1./3.); if(dist_s <= 0.5) { particleWeights[ii][jj] = 1./4.*pow(dist_s,4)-5./8.*pow(dist_s,2)+115./192.; } else if (dist_s > 0.5 && dist_s <= 1.5) { particleWeights[ii][jj] = -1./6.*pow(dist_s,4)+5./6.*pow(dist_s,3)-5./4.*pow(dist_s,2)+5./24.*dist_s+55./96.; } else if (dist_s > 1.5 && dist_s <= 2.5) { particleWeights[ii][jj] = pow(2.5-dist_s,4)/24.; } else { particleWeights[ii][jj] = 0; } sumWeights += particleWeights[ii][jj]; } forAll(cellsNeigh,jj) { if ( sumWeights != 0 ) { Up_[cellID] += Up*particleWeights[ii][jj]/sumWeights; MappedDragForce_[cellID] += (WenYuDrag + Volp * gradPg_int) * particleWeights[ii][jj]/sumWeights; } else { Up_[cellID] = vector(0,0,0); MappedDragForce_[cellID] = vector(0,0,0); } } } else {
void Foam::kineticTheoryModel::solve(const volTensorField& gradUat, const volScalarField& kb,const volScalarField& epsilonb,const volScalarField& nutf,const dimensionedScalar& B, const dimensionedScalar& tt) { if (!kineticTheory_) { return; } const scalar sqrtPi = sqrt(constant::mathematical::pi); // surfaceScalarField phi = 1.5*rhoa_*phia_*fvc::interpolate(max(alpha_,DiluteCut_)); surfaceScalarField phi = 1.5*rhoa_*phia_*fvc::interpolate((alpha_+1e-8)); volTensorField dUU = gradUat.T(); //that is fvc::grad(Ua_); volSymmTensorField D = symm(dUU); //0.5*(dU + dU.T) volTensorField dU = dUU;//dev(dUU); // NB, drag = K*alpha*beta, // (the alpha and beta has been extracted from the drag function for // numerical reasons) // this is inconsistent with momentum equation, since the following form missed // the drift velocity volScalarField Ur_ = mag(Ua_ - Ub_); // volScalarField Ur = mag(Ua_ - Ub_ + nuft/(max(alpha_,1e-9)*(1.0-alpha_))*fvc::grad(alpha_)); // volScalarField Ur = mag(Ua_ - Ub_ + nuft/(max(alpha_,1e-9))*fvc::grad(alpha_)); volScalarField betaPrim = (1.0 - alpha_)*draga_.K(Ur_); // Calculating the radial distribution function (solid volume fraction is // limited close to the packing limit, but this needs improvements) // The solution is higly unstable close to the packing limit. gs0_ = radialModel_->g0 ( min(alpha_, alphaMax_ - 1e-9), alphaMax_ ); // particle pressure - coefficient in front of Theta (Eq. 3.22, p. 45) volScalarField PsCoeff = granularPressureModel_->granularPressureCoeff ( alpha_, // (alpha_+1e-12), gs0_, rhoa_, e_ ); // 'thermal' conductivity (Table 3.3, p. 49) kappa_ = conductivityModel_->kappa(alpha_, Theta_, gs0_, rhoa_, da_, e_); // particle viscosity (Table 3.2, p.47) // mua_ = viscosityModel_->mua(alpha_, Theta_, gs0_, rhoa_, da_, e_); dimensionedScalar Tsmall ( "small", dimensionSet(0 , 2 ,-2 ,0 , 0, 0, 0), scalar(1.0e-40) ); dimensionedScalar TsmallEqn ( "small", dimensionSet(0 , 2 ,-2 ,0 , 0, 0, 0), scalar(1.0e-30) ); dimensionedScalar TsmallSqrt = sqrt(Tsmall); volScalarField ThetaSqrt = sqrt(Theta_); volScalarField muaa = rhoa_*da_* ( (4.0/5.0)*sqr(alpha_)*gs0_*(1.0 + e_)/sqrtPi + (1.0/15.0)*sqrtPi*gs0_*(1.0 + e_)*sqr(alpha_) + (1.0/6.0)*sqrtPi*alpha_ + (10.0/96.0)*sqrtPi/((1.0 + e_)*gs0_) )/(ThetaSqrt+TsmallSqrt); // dissipation (Eq. 3.24, p.50) volScalarField gammaCoeff = 3.0*(1.0 - sqr(e_))*sqr(alpha_)*rhoa_*gs0_*((4.0/da_)*ThetaSqrt/sqrtPi-tr(D)); // 3.0*(1.0 - sqr(e_))*sqr(alpha_)*rhoa_*gs0_*((4.0/da_)*ThetaSqrt/sqrtPi); // Eq. 3.25, p. 50 Js = J1 - J2 // The following is to calculate parameter tmf_ in u_f*u_s correlation dimensionedScalar Tpsmall_ ( "Tpsmall_", dimensionSet(1, -1, -3, 0, 0, 0, 0), scalar(1e-30) ); volScalarField tmf_ = Foam::exp(-B*rhoa_*scalar(6.0)*epsilonb/(max(kb*betaPrim,Tpsmall_))); volScalarField J1 = 3.0*alpha_*betaPrim; volScalarField J2 = 0.25*alpha_*sqr(betaPrim)*da_*sqr(Ur_) /(rhoa_*sqrtPi*(max(ThetaSqrt,TsmallSqrt))); // bulk viscosity p. 45 (Lun et al. 1984). // lambda_ = (4.0/3.0)*sqr(alpha_)*rhoa_*da_*gs0_*(1.0+e_)*ThetaSqrt/sqrtPi; volScalarField lambdaa = (4.0/3.0)*sqr(alpha_)*rhoa_*da_*gs0_*(1.0+e_)/(sqrtPi*(ThetaSqrt+TsmallSqrt)); // stress tensor, Definitions, Table 3.1, p. 43 // volSymmTensorField tau = 2.0*mua_*D + (lambda_ - (2.0/3.0)*mua_)*tr(D)*I; volSymmTensorField tau = scalar(2.0)*muaa*D + (lambdaa - (scalar(2.0)/scalar(3.0))*muaa)*tr(D)*I; dimensionedScalar alphasmall ( "alphasmall", dimensionSet(0, 0, 0, 0, 0, 0, 0), scalar(1e-9) ); if (!equilibrium_) { // construct the granular temperature equation (Eq. 3.20, p. 44) // NB. note that there are two typos in Eq. 3.20 // no grad infront of Ps // wrong sign infront of laplacian fvScalarMatrix ThetaEqn ( fvm::ddt(1.5*(alpha_+1e-8)*rhoa_, Theta_) + fvm::div(phi, Theta_, "div(phi,Theta)") == //Ps term. fvm::SuSp(-((PsCoeff*I) && dU), Theta_) //production due to shear. + fvm::SuSp((tau && dU),Theta_) // + (tau && dU) // granular temperature conduction. + fvm::laplacian(kappa_, Theta_, "laplacian(kappa,Theta)") //energy disipation due to inelastic collision. + fvm::SuSp(-gammaCoeff, Theta_) // + fvm::SuSp(-J1, Theta_) + (scalar(2.0)/scalar(3.0))*J1*tmf_*kb ); ThetaEqn.relax(); ThetaEqn.solve(); } else { // equilibrium => dissipation == production // Eq. 4.14, p.82 volScalarField K1 = 2.0*(1.0 + e_)*rhoa_*gs0_; volScalarField K3 = 0.5*da_*rhoa_* ( (sqrtPi/(3.0*(3.0-e_))) *(1.0 + 0.4*(1.0 + e_)*(3.0*e_ - 1.0)*alpha_*gs0_) +1.6*alpha_*gs0_*(1.0 + e_)/sqrtPi ); volScalarField K2 = 4.0*da_*rhoa_*(1.0 + e_)*alpha_*gs0_/(3.0*sqrtPi) - 2.0*K3/3.0; volScalarField K4 = 12.0*(1.0 - sqr(e_))*rhoa_*gs0_/(da_*sqrtPi); volScalarField trD = tr(D); volScalarField tr2D = sqr(trD); volScalarField trD2 = tr(D & D); volScalarField t1 = K1*alpha_; volScalarField l1 = -t1*trD; volScalarField l2 = sqr(t1)*tr2D; volScalarField l3 = 4.0*K4*alpha_*(2.0*K3*trD2 + K2*tr2D); Theta_ = sqr((l1 + sqrt(l2 + l3))/(2.0*(alpha_ + 1.0e-4)*K4)); } forAll(alpha_, cellk) { // for initial stability if(tt.value() <= ttzero.value() && alpha_[cellk]>= 0) { Theta_[cellk] = 0.0*Theta_[cellk]; } if(tt.value() <= ttone.value() && alpha_[cellk] >= 0.5) { Theta_[cellk] = 0.0*Theta_[cellk]; } // to cut off in dilute limit, set DiluteCut < 0 to turn this off if(tt.value()>=ttone.value() && alpha_[cellk] <= DiluteCut_.value()) { Theta_[cellk] = 0.0*Theta_[cellk]; } } Theta_.max(0.0e-40); Theta_.min(MaxTheta); // need to update after solving Theta Equation. PsCoeff = granularPressureModel_->granularPressureCoeff ( alpha_, gs0_, rhoa_, e_ ); // update bulk viscosity and shear viscosity // bulk viscosity p. 45 (Lun et al. 1984). lambda_ = (4.0/3.0)*sqr(alpha_)*rhoa_*da_*gs0_*(1.0+e_)*sqrt(Theta_)/sqrtPi; // particle viscosity (Table 3.2, p.47) mua_ = viscosityModel_->mua(alpha_, Theta_, gs0_, rhoa_, da_, e_); pf = frictionalStressModel_->frictionalPressure ( alpha_, alphaMinFriction_, alphaMax_, Fr_, eta_, p_ ); // yes, after solving Theta, because frictional stress is not a part of kinetic theoty // PsCoeff = PsCoeff + pf/(max(Theta_,Tsmall)); PsCoeff.min(1e+6); PsCoeff.max(-1e+6); // update particle pressure, just from the kinetic part pa_ = PsCoeff*Theta_; // frictional shear stress, Eq. 3.30, p. 52 volScalarField muf = frictionalStressModel_->muf ( alpha_, Theta_, alphaMinFriction_, alphaMax_, pf, D, phi_ ); // add frictional stress mua_ = mua_+muf; mua_.max(0.0); Info<< "kinTheory: max(Theta) = " << max(Theta_).value() <<" min(Theta) = "<<min(Theta_).value()<< endl; volScalarField ktn = mua_/rhoa_; Info<< "kinTheory: min(nua) = " << min(ktn).value() << ", max(nua) = " << max(ktn).value() << endl; Info<< "kinTheory: min(pa) = " << min(pa_).value() << ", max(pa) = " << max(pa_).value() << endl; }
// from components Feta_PTT::Feta_PTT ( const word& name, const volScalarField& alpha, const volVectorField& U, const surfaceScalarField& phi, const dictionary& dict ) : viscoelasticLaw(name, alpha, U, phi), tau_ ( IOobject ( "tau" + name, U.time().timeName(), U.mesh(), IOobject::MUST_READ, IOobject::AUTO_WRITE ), U.mesh() ), etaS1_(dict.subDict("phase1").lookup("etaS")), etaS2_(dict.subDict("phase2").lookup("etaS")), etaP1_(dict.subDict("phase1").lookup("etaP")), etaP2_(dict.subDict("phase2").lookup("etaP")), lambda1_(dict.subDict("phase1").lookup("lambda")), lambda2_(dict.subDict("phase2").lookup("lambda")), epsilon1_(dict.subDict("phase1").lookup("epsilon")), epsilon2_(dict.subDict("phase2").lookup("epsilon")), zeta1_(dict.subDict("phase1").lookup("zeta")), zeta2_(dict.subDict("phase2").lookup("zeta")), A1_(dict.subDict("phase1").lookup("A")), A2_(dict.subDict("phase2").lookup("A")), a1_(dict.subDict("phase1").lookup("a")), a2_(dict.subDict("phase2").lookup("a")), b1_(dict.subDict("phase1").lookup("b")), b2_(dict.subDict("phase2").lookup("b")), alpha1f_ ( IOobject ( "alpha1f" + name, U.time().timeName(), U.mesh(), IOobject::NO_READ, IOobject::NO_WRITE ), min(max(alpha, scalar(0)), scalar(1)) ), etaPEff_ ( IOobject ( "etaPEff" + name, U.time().timeName(), U.mesh(), IOobject::NO_READ, IOobject::AUTO_WRITE ), (etaP1_/( Foam::pow(scalar(1) + A1_*Foam::pow(0.5*( Foam::sqr(tr(tau_)) - tr(tau_ & tau_) ) * Foam::sqr(lambda1_) / Foam::sqr(etaP1_), a1_), b1_) ) )*alpha1f_ + (etaP2_/( Foam::pow(scalar(1) + A2_*Foam::pow(0.5*( Foam::sqr(tr(tau_)) - tr(tau_ & tau_) ) * Foam::sqr(lambda2_) / Foam::sqr(etaP2_), a2_), b2_) ) )*(scalar(1) - alpha1f_) ), lambdaEff_ ( IOobject ( "lambdaEff" + name, U.time().timeName(), U.mesh(), IOobject::NO_READ, IOobject::AUTO_WRITE ), (lambda1_ / (scalar(1) + epsilon1_*lambda1_*tr(tau_) / etaP1_) )*alpha1f_ + (lambda2_ / (scalar(1) + epsilon2_*lambda2_*tr(tau_) / etaP2_) )*(scalar(1) - alpha1f_) ) {}
void realizableKE_Veh::correct() { RASModel::correct(); if (!turbulence_) { return; } const volTensorField gradU(fvc::grad(U_)); const volScalarField S2(2*magSqr(dev(symm(gradU)))); const volScalarField magS(sqrt(S2)); const volScalarField eta(magS*k_/epsilon_); tmp<volScalarField> C1 = max(eta/(scalar(5) + eta), scalar(0.43)); volScalarField G("RASModel::G", nut_*S2); //Estimating source terms for vehicle canopy volVectorField Fi = 0.5*Cfcar_*VAD_*mag(U_-Ucar_)*(U_-Ucar_); volScalarField Fk = (U_-Ucar_)&Fi; volScalarField Fepsilon = epsilon_*sqrt(k_)*Cecar_/L_; // Update epsilon and G at the wall epsilon_.boundaryField().updateCoeffs(); // Dissipation equation tmp<fvScalarMatrix> epsEqn ( fvm::ddt(epsilon_) + fvm::div(phi_, epsilon_) - fvm::Sp(fvc::div(phi_), epsilon_) - fvm::laplacian(DepsilonEff(), epsilon_) == Fepsilon + C1*magS*epsilon_ - fvm::Sp ( C2_*epsilon_/(k_ + sqrt(nu()*epsilon_)), epsilon_ ) ); epsEqn().relax(); epsEqn().boundaryManipulate(epsilon_.boundaryField()); solve(epsEqn); bound(epsilon_, epsilonMin_); // Turbulent kinetic energy equation tmp<fvScalarMatrix> kEqn ( fvm::ddt(k_) + fvm::div(phi_, k_) - fvm::Sp(fvc::div(phi_), k_) - fvm::laplacian(DkEff(), k_) == Fk + G - fvm::Sp(epsilon_/k_, k_) ); kEqn().relax(); solve(kEqn); bound(k_, kMin_); // Re-calculate viscosity nut_ = rCmu(gradU, S2, magS)*sqr(k_)/epsilon_; nut_.correctBoundaryConditions(); }
} // Rt_ /= mesh_.nCells(); Rt_ /= binModel_->nBins(); // const scalar& timeIndex = time_.averagingTimeIndex(); // RtField_[timeIndex] = Rt_; // if(Pstream::parRun()) // { // reduce(RtField_[timeIndex], sumOp<scalar>()); // } RtField_[timeIndex_] = Rt_; timeIndex_++; n_ = scalar(0.0); //- reset // if(time_.resetFieldsAtOutput()) // { // mass_ = scalar(0.0); // resetCounter_ = scalar(0.0); // } // Info << "reset" << endl; // } } //- return field // const volScalarField& crbsFluctuationsZone::densityField() const
void Foam::JohnsonJacksonParticleThetaFvPatchScalarField::updateCoeffs() { if (updated()) { return; } // lookup the fluid model and the phase const twoPhaseSystem& fluid = db().lookupObject<twoPhaseSystem> ( "phaseProperties" ); const phaseModel& phased ( fluid.phase1().name() == internalField().group() ? fluid.phase1() : fluid.phase2() ); // lookup all the fields on this patch const fvPatchScalarField& alpha ( patch().lookupPatchField<volScalarField, scalar> ( phased.volScalarField::name() ) ); const fvPatchVectorField& U ( patch().lookupPatchField<volVectorField, vector> ( IOobject::groupName("U", phased.name()) ) ); const fvPatchScalarField& gs0 ( patch().lookupPatchField<volScalarField, scalar> ( IOobject::groupName("gs0", phased.name()) ) ); const fvPatchScalarField& kappa ( patch().lookupPatchField<volScalarField, scalar> ( IOobject::groupName("kappa", phased.name()) ) ); const scalarField Theta(patchInternalField()); // lookup the packed volume fraction dimensionedScalar alphaMax ( "alphaMax", dimless, db() .lookupObject<IOdictionary> ( IOobject::groupName("turbulenceProperties", phased.name()) ) .subDict("RAS") .subDict("kineticTheoryCoeffs") .lookup("alphaMax") ); // calculate the reference value and the value fraction if (restitutionCoefficient_.value() != 1.0) { this->refValue() = (2.0/3.0) *specularityCoefficient_.value() *magSqr(U) /(scalar(1) - sqr(restitutionCoefficient_.value())); this->refGrad() = 0.0; scalarField c ( constant::mathematical::pi *alpha *gs0 *(scalar(1) - sqr(restitutionCoefficient_.value())) *sqrt(3*Theta) /max(4*kappa*alphaMax.value(), small) ); this->valueFraction() = c/(c + patch().deltaCoeffs()); } // for a restitution coefficient of 1, the boundary degenerates to a fixed // gradient condition else { this->refValue() = 0.0; this->refGrad() = pos0(alpha - small) *constant::mathematical::pi *specularityCoefficient_.value() *alpha *gs0 *sqrt(3*Theta) *magSqr(U) /max(6*kappa*alphaMax.value(), small); this->valueFraction() = 0; } mixedFvPatchScalarField::updateCoeffs(); }
multivariateSelectionScheme<Type>::multivariateSelectionScheme ( const fvMesh& mesh, const typename multivariateSurfaceInterpolationScheme<Type>:: fieldTable& fields, const surfaceScalarField& faceFlux, Istream& schemeData ) : multivariateSurfaceInterpolationScheme<Type> ( mesh, fields, faceFlux, schemeData ), schemes_(schemeData), faceFlux_(faceFlux), weights_ ( IOobject ( "multivariateWeights", mesh.time().timeName(), mesh ), mesh, dimless ) { typename multivariateSurfaceInterpolationScheme<Type>:: fieldTable::const_iterator iter = this->fields().begin(); surfaceScalarField limiter = ( limitedSurfaceInterpolationScheme<Type>::New ( mesh, faceFlux_, schemes_.lookup(iter()->name()) )().limiter(*iter()) ); for (++iter; iter != this->fields().end(); ++iter) { limiter = min ( limiter, limitedSurfaceInterpolationScheme<Type>::New ( mesh, faceFlux_, schemes_.lookup(iter()->name()) )().limiter(*iter()) ); } weights_ = limiter*mesh.surfaceInterpolation::weights() + (scalar(1) - limiter)*upwind<Type>(mesh, faceFlux_).weights(); }
StatsDialog::StatsDialog(const FiberTracts &fibers, const QList<quint32> *selectedFibers, const cube &volume, bool isLabel, QWidget *parent) : QDialog(parent) { setupUi(this); tableWidget->setHorizontalHeaderLabels(QStringList() << "" << "All Fibers" << "Selected"); if (fibers.isEmpty()) return; // Fill the table // get min, max, mean points int minTpoints=10000, maxTpoints=0; double sumTpoints=0, meanTpoints; for (int i=0; i<fibers.size();i++) { if (minTpoints > fibers.getFiber(i).size()) minTpoints = fibers.getFiber(i).size(); if(maxTpoints < fibers.getFiber(i).size()) maxTpoints = fibers.getFiber(i).size(); sumTpoints += fibers.getFiber(i).size(); } meanTpoints = sumTpoints/fibers.size(); // get min, max, mean, std for the scalar vec scalar = Col<double>(sumTpoints,1); quint32 c = 0, x, y, z; int rows = volume.n_rows, cols = volume.n_cols, slices = volume.n_slices; for (int i=0; i<fibers.size();i++) { for (int j=0; j<fibers.getFiber(i).size();j++) { x = qMax(qMin(qRound(fibers.getFiber(i).at(j).x()),rows-1),0); y = qMax(qMin(qRound(fibers.getFiber(i).at(j).y()),cols-1),0); z = qMax(qMin(qRound(fibers.getFiber(i).at(j).z()),slices-1),0); scalar(c) = volume(x,y,z); c++; } } // fill All fibers stats tableWidget->item(0,1)->setText(QString::number(fibers.size(),'g',6)); tableWidget->item(1,1)->setText(QString::number(minTpoints,'g',6)); tableWidget->item(2,1)->setText(QString::number(maxTpoints,'g',6)); tableWidget->item(3,1)->setText(QString::number(meanTpoints,'g',6)); tableWidget->item(4,1)->setText(QString::number(fibers.minLength(),'g',6)); tableWidget->item(5,1)->setText(QString::number(fibers.maxLength(),'g',6)); tableWidget->item(6,1)->setText(QString::number(fibers.meanLength(),'g',6)); if (!isLabel) { tableWidget->item(7,1)->setText(QString::number(scalar.min(),'g',6)); tableWidget->item(8,1)->setText(QString::number(scalar.max(),'g',6)); tableWidget->item(9,1)->setText(QString::number(arma::mean(scalar),'g',6)); tableWidget->item(10,1)->setText(QString::number(arma::stddev(scalar),'g',6)); } // fill selected fibers stats if (selectedFibers) { // get min, max, mean points, min, max, mean length minTpoints=10000; maxTpoints=0; sumTpoints=0; double minL = 100000, maxL=0, sumL = 0, meanL; int idx; for (int i=0; i<selectedFibers->size();i++) { idx = selectedFibers->at(i); // points if (minTpoints > fibers.getFiber(idx).size()) minTpoints = fibers.getFiber(idx).size(); if(maxTpoints < fibers.getFiber(idx).size()) maxTpoints = fibers.getFiber(idx).size(); sumTpoints += fibers.getFiber(idx).size(); // length if (minL > fibers.getLength(i)) minL = fibers.getLength(i); if (maxL < fibers.getLength(i)) maxL = fibers.getLength(i); sumL += fibers.getLength(i); } meanTpoints = sumTpoints/selectedFibers->size(); meanL = sumL/selectedFibers->size(); // get min, max, mean, std for the scalar scalar = Col<double>(sumTpoints,1); c = 0; for (int i=0; i<selectedFibers->size();i++) { idx = selectedFibers->at(i); for (int j=0; j<fibers.getFiber(idx).size();j++) { x = qMax(qMin(qRound(fibers.getFiber(idx).at(j).x()),rows-1),0); y = qMax(qMin(qRound(fibers.getFiber(idx).at(j).y()),cols-1),0); z = qMax(qMin(qRound(fibers.getFiber(idx).at(j).z()),slices-1),0); scalar(c) = volume(x,y,z); c++; } } tableWidget->item(0,2)->setText(QString::number(selectedFibers->size(),'g',6)); tableWidget->item(1,2)->setText(QString::number(minTpoints,'g',6)); tableWidget->item(2,2)->setText(QString::number(maxTpoints,'g',6)); tableWidget->item(3,2)->setText(QString::number(meanTpoints,'g',6)); tableWidget->item(4,2)->setText(QString::number(minL,'g',6)); tableWidget->item(5,2)->setText(QString::number(maxL,'g',6)); tableWidget->item(6,2)->setText(QString::number(meanL,'g',6)); if (!isLabel) { tableWidget->item(7,2)->setText(QString::number(scalar.min(),'g',6)); tableWidget->item(8,2)->setText(QString::number(scalar.max(),'g',6)); tableWidget->item(9,2)->setText(QString::number(arma::mean(scalar),'g',6)); tableWidget->item(10,2)->setText(QString::number(arma::stddev(scalar),'g',6)); } } tableWidget->resizeColumnsToContents(); updateGeometry(); setFixedSize(this->size()); }
int main(int argc, char *argv[]) { timeSelector::addOptions(); # include "addRegionOption.H" argList::validArgs.append("patchName"); argList::validArgs.append("firstPatchNumber"); argList::validArgs.append("lastPatchNumber"); # include "setRootCase.H" # include "createTime.H" instantList timeDirs = timeSelector::select0(runTime, args); # include "createNamedMesh.H" word patchName = args[1]; const word charfirstPatchNumber = args[2]; const word charlastPatchNumber = args[3]; char* pEnd; int firstPatchNumber = strtod(charfirstPatchNumber.c_str(), &pEnd); int lastPatchNumber = strtod(charlastPatchNumber.c_str(), &pEnd); Info << "Patch name: " << patchName << " id = ["<< charfirstPatchNumber <<":"<< charlastPatchNumber <<"]" << endl; Info << " " << endl; OFstream* outputFile; fileName outpuFilename(mesh.time().path()/"wettedAreaPatch"+patchName+charfirstPatchNumber+"-"+charlastPatchNumber); outputFile = new OFstream(outpuFilename); *outputFile << "#Time " << tab << "totalWettedArea" << tab; for(label id=firstPatchNumber; id<=lastPatchNumber; id++) { *outputFile << "wettedArea-" << id << tab; } *outputFile << endl; forAll(timeDirs, timeI) { runTime.setTime(timeDirs[timeI], timeI); Info<< "Time = " << runTime.timeName() << endl; mesh.readUpdate(); // Read gas density IOobject alphaheader ( "alpha.water", runTime.timeName(), mesh, IOobject::MUST_READ ); Info<< " Reading alpha" << endl; volScalarField alpha(alphaheader,mesh); scalar totalWettedArea(0); scalarField wettedArea(lastPatchNumber+1,scalar(0)); scalar totalSurfaceArea(0); for(label id=firstPatchNumber; id<=lastPatchNumber; id++) { // Calculate wetted area on the plane word patchNumber; std::stringstream ss; ss << id; patchNumber = ss.str(); const label patchI = mesh.boundaryMesh().findPatchID(patchName+patchNumber); if (patchI < 0) { FatalError << "Unable to find patch " << patchName << nl << exit(FatalError); } wettedArea[id] = gSum(alpha.boundaryField()[patchI]*mesh.magSf().boundaryField()[patchI]); totalWettedArea += wettedArea[id]; totalSurfaceArea += gSum(mesh.magSf().boundaryField()[patchI]); } if(Pstream::master()) //Write only if master { Info<< " Writing mass flow rates into the file " << outpuFilename << endl; *outputFile << alpha.mesh().time().value() << tab << totalWettedArea << tab; for(label id=firstPatchNumber; id<=lastPatchNumber; id++) { *outputFile << wettedArea[id] << tab << " "; } *outputFile << totalSurfaceArea << endl; } Info << " " << endl; }
void Foam::GAMGAgglomeration::compactLevels(const label nCreatedLevels) { nCells_.setSize(nCreatedLevels); restrictAddressing_.setSize(nCreatedLevels); nFaces_.setSize(nCreatedLevels); faceRestrictAddressing_.setSize(nCreatedLevels); faceFlipMap_.setSize(nCreatedLevels); nPatchFaces_.setSize(nCreatedLevels); patchFaceRestrictAddressing_.setSize(nCreatedLevels); meshLevels_.setSize(nCreatedLevels); // Have procCommunicator_ always, even if not procAgglomerating procCommunicator_.setSize(nCreatedLevels + 1); if (processorAgglomerate()) { procAgglomMap_.setSize(nCreatedLevels); agglomProcIDs_.setSize(nCreatedLevels); procCellOffsets_.setSize(nCreatedLevels); procFaceMap_.setSize(nCreatedLevels); procBoundaryMap_.setSize(nCreatedLevels); procBoundaryFaceMap_.setSize(nCreatedLevels); procAgglomeratorPtr_().agglomerate(); } // Print a bit if (processorAgglomerate() && debug) { Info<< "GAMGAgglomeration:" << nl << " local agglomerator : " << type() << nl; if (processorAgglomerate()) { Info<< " processor agglomerator : " << procAgglomeratorPtr_().type() << nl << nl; } Info<< setw(36) << "nCells" << setw(20) << "nFaces/nCells" << setw(20) << "nInterfaces" << setw(20) << "nIntFaces/nCells" << setw(12) << "profile" << nl << setw(8) << "Level" << setw(8) << "nProcs" << " " << setw(8) << "avg" << setw(8) << "max" << " " << setw(8) << "avg" << setw(8) << "max" << " " << setw(8) << "avg" << setw(8) << "max" << " " << setw(8) << "avg" << setw(8) << "max" //<< " " << setw(12) << "avg" << nl << setw(8) << "-----" << setw(8) << "------" << " " << setw(8) << "---" << setw(8) << "---" << " " << setw(8) << "---" << setw(8) << "---" << " " << setw(8) << "---" << setw(8) << "---" << " " << setw(8) << "---" << setw(8) << "---" //<< " " << setw(12) << "---" //<< " " << nl; for (label levelI = 0; levelI <= size(); levelI++) { label nProcs = 0; label nCells = 0; scalar faceCellRatio = 0; label nInterfaces = 0; label nIntFaces = 0; scalar ratio = 0.0; scalar profile = 0.0; if (hasMeshLevel(levelI)) { nProcs = 1; const lduMesh& fineMesh = meshLevel(levelI); nCells = fineMesh.lduAddr().size(); faceCellRatio = scalar(fineMesh.lduAddr().lowerAddr().size())/nCells; const lduInterfacePtrsList interfaces = fineMesh.interfaces(); forAll(interfaces, i) { if (interfaces.set(i)) { nInterfaces++; nIntFaces += interfaces[i].faceCells().size(); } } ratio = scalar(nIntFaces)/nCells; profile = fineMesh.lduAddr().band().second(); } label totNprocs = returnReduce(nProcs, sumOp<label>()); label maxNCells = returnReduce(nCells, maxOp<label>()); label totNCells = returnReduce(nCells, sumOp<label>()); scalar maxFaceCellRatio = returnReduce(faceCellRatio, maxOp<scalar>()); scalar totFaceCellRatio = returnReduce(faceCellRatio, sumOp<scalar>()); label maxNInt = returnReduce(nInterfaces, maxOp<label>()); label totNInt = returnReduce(nInterfaces, sumOp<label>()); scalar maxRatio = returnReduce(ratio, maxOp<scalar>()); scalar totRatio = returnReduce(ratio, sumOp<scalar>()); scalar totProfile = returnReduce(profile, sumOp<scalar>()); int oldPrecision = Info().precision(4); Info<< setw(8) << levelI << setw(8) << totNprocs << " " << setw(8) << totNCells/totNprocs << setw(8) << maxNCells << " " << setw(8) << totFaceCellRatio/totNprocs << setw(8) << maxFaceCellRatio << " " << setw(8) << scalar(totNInt)/totNprocs << setw(8) << maxNInt << " " << setw(8) << totRatio/totNprocs << setw(8) << maxRatio << setw(12) << totProfile/totNprocs << nl; Info().precision(oldPrecision); } Info<< endl; }
void multiply ( scalarSquareMatrix& ans, // value changed in return const scalarRectangularMatrix& A, const scalarRectangularMatrix& B, const scalarRectangularMatrix& C, const scalarDiagonalMatrix& D ) { if (A.m() != B.n()) { FatalErrorIn ( "multiply(" "scalarRectangularMatrix& answer)," "const scalarRectangularMatrix& A, " "const scalarRectangularMatrix& B, " "const scalarRectangularMatrix& C, " "const DiagonalMatrix<scalar>& D" ) << "A and B must have identical inner dimensions but A.m = " << A.m() << " and B.n = " << B.n() << abort(FatalError); } if (B.m() != C.n()) { FatalErrorIn ( "multiply(" "scalarRectangularMatrix& answer)," "const scalarRectangularMatrix& A, " "const scalarRectangularMatrix& B, " "const scalarRectangularMatrix& C, " "const DiagonalMatrix<scalar>& D" ) << "B and C must have identical inner dimensions but B.m = " << B.m() << " and C.n = " << C.n() << abort(FatalError); } if (C.m() != D.size()) { FatalErrorIn ( "multiply(" "scalarRectangularMatrix& answer)," "const scalarRectangularMatrix& A, " "const scalarRectangularMatrix& B, " "const scalarRectangularMatrix& C, " "const DiagonalMatrix<scalar>& D" ) << "C and D must have identical inner dimensions but C.m = " << C.m() << " and D.n = " << D.size() << abort(FatalError); } ans = scalarSquareMatrix(D.size(), D.size(), scalar(0)); for (register label i = 0; i < A.n(); i++) { for (register label g = 0; g < C.m(); g++) { for (register label l = 0; l < C.n(); l++) { scalar ab = 0; for (register label j = 0; j < A.m(); j++) { ab += A[i][j]*B[j][l]; } ans[i][g] += C[l][g] * ab; } ans[i][g] = ans[i][g] * D[g]; } } }
double ASENSOR::ConvertValue( double volts ) { SampleVolts(scalar(volts)); return(SensorValues(1,1)); }
void Foam::inclinedFilmNusseltHeightFvPatchScalarField::updateCoeffs() { if (updated()) { return; } const label patchi = patch().index(); // retrieve the film region from the database const regionModels::regionModel& region = db().time().lookupObject<regionModels::regionModel> ( "surfaceFilmProperties" ); const regionModels::surfaceFilmModels::kinematicSingleLayer& film = dynamic_cast < const regionModels::surfaceFilmModels::kinematicSingleLayer& >(region); // calculate the vector tangential to the patch // note: normal pointing into the domain const vectorField n(-patch().nf()); // TODO: currently re-evaluating the entire gTan field to return this patch const scalarField gTan(film.gTan()().boundaryField()[patchi] & n); if (patch().size() && (max(mag(gTan)) < small)) { WarningInFunction << "is designed to operate on patches inclined with respect to " << "gravity" << endl; } const volVectorField& nHat = film.nHat(); const vectorField nHatp(nHat.boundaryField()[patchi].patchInternalField()); vectorField nTan(nHatp ^ n); nTan /= mag(nTan) + rootVSmall; // calculate distance in patch tangential direction const vectorField& Cf = patch().Cf(); scalarField d(nTan & Cf); // calculate the wavy film height const scalar t = db().time().timeOutputValue(); const scalar GMean = GammaMean_->value(t); const scalar a = a_->value(t); const scalar omega = omega_->value(t); const scalarField G(GMean + a*sin(omega*constant::mathematical::twoPi*d)); const volScalarField& mu = film.mu(); const scalarField mup(mu.boundaryField()[patchi].patchInternalField()); const volScalarField& rho = film.rho(); const scalarField rhop(rho.boundaryField()[patchi].patchInternalField()); const scalarField Re(max(G, scalar(0))/mup); operator== ( pow(3*sqr(mup/rhop)/(gTan + rootVSmall), 1.0/3.0)*pow(Re, 1.0/3.0) ); fixedValueFvPatchScalarField::updateCoeffs(); }
// count blocks: currentBlock += region.blocks; } // translate to weights: forAll(positions,pI){ scalar p1 = positions[pI]; scalar p0 = pI == 0 ? 0 : positions[pI - 1]; weights[dir][pI] = (p1 - p0) / moduleBase().domainBox_.lengths()[dir]; } } } // calc deltas: scalarList sum(3,scalar(0)); forAll(weights[TerrainManager::BASE1],wI) sum[TerrainManager::BASE1] += weights[TerrainManager::BASE1][wI]; forAll(weights[TerrainManager::BASE2],wI) sum[TerrainManager::BASE2] += weights[TerrainManager::BASE2][wI]; scalar pc = 0; forAll(weights[TerrainManager::BASE1],wI){ blockGrading[TerrainManager::BASE1][wI + 1] = moduleBase().domainBox_.lengths()[TerrainManager::BASE1] * weights[TerrainManager::BASE1][wI] / sum[TerrainManager::BASE1]; pc += blockGrading[TerrainManager::BASE1][wI]; } forAll(weights[TerrainManager::BASE2],wI){ blockGrading[TerrainManager::BASE2][wI + 1] = moduleBase().domainBox_.lengths()[TerrainManager::BASE2] * weights[TerrainManager::BASE2][wI] / sum[TerrainManager::BASE2]; } // calc cell gradings: scalarListList cellGradingL(cellGrading);
/** This function returns the angle btw the triangle p1,p2,p3 and p2,p3,p4. * Be careful, the angle depends on the orientation of the trianlges! * You need to be sure that the orientation (direction of normal vector) * of p1p2p3 is given by the cross product p2p1 x p2p3. * The orientation of p2p3p4 must be given by p2p3 x p2p4. * * Example: p1 = (0,0,1), p2 = (0,0,0), p3=(1,0,0), p4=(0,1,0). * The orientation of p1p2p3 should be in the direction (0,1,0) * and indeed: p2p1 x p2p3 = (0,0,1)x(1,0,0) = (0,1,0) * This function is called in the beginning of the simulation when creating * bonds depending on the angle btw the triangles, the bending_force. * Here, we determine the orientations by looping over the triangles * and checking the correct orientation. So when defining the bonds by tcl * command * "part p2 bond xxxx p1 p3 p4", we correctly input the particle id's. * So if you have the access to the order of particles, you are safe to call * this * function with exactly this order. Otherwise you need to check the * orientations. */ inline double angle_btw_triangles(double *P1, double *P2, double *P3, double *P4) { double phi; double u[3], v[3], normal1[3], normal2[3]; // auxiliary variables u[0] = P1[0] - P2[0]; // u = P2P1 u[1] = P1[1] - P2[1]; u[2] = P1[2] - P2[2]; v[0] = P3[0] - P2[0]; // v = P2P3 v[1] = P3[1] - P2[1]; v[2] = P3[2] - P2[2]; vector_product(u, v, normal1); u[0] = P3[0] - P2[0]; // u = P2P3 u[1] = P3[1] - P2[1]; u[2] = P3[2] - P2[2]; v[0] = P4[0] - P2[0]; // v = P2P4 v[1] = P4[1] - P2[1]; v[2] = P4[2] - P2[2]; vector_product(u, v, normal2); double tmp11, tmp22, tmp33; // Now we compute the scalar product of n1 and n2 divided by the norms of n1 // and n2 // tmp11 = dot(3,normal1,normal2); // tmp11 = n1.n2 tmp11 = scalar(normal1, normal2); // tmp11 = n1.n2 /* tmp22 = normr(normal1); tmp33 = normr(normal2); tmp11 /= (tmp22*tmp33); // tmp11 = n1.n2/(|n1||n2|) */ tmp11 *= fabs(tmp11); // tmp11 = (n1.n2)^2 tmp22 = sqrlen(normal1); // tmp22 = |n1|^2 tmp33 = sqrlen(normal2); // tmp33 = |n1|^2 tmp11 /= (tmp22 * tmp33); // tmp11 = (n1.n2/(|n1||n2|))^2 if (tmp11 > 0) { tmp11 = sqrt(tmp11); } else { tmp11 = -sqrt(-tmp11); } if (tmp11 >= 1.) { tmp11 = 0.0; } else if (tmp11 <= -1.) { tmp11 = M_PI; } phi = M_PI - acos(tmp11); // The angle between the faces (not considering the // orientation, always less or equal to Pi) is // equal to Pi minus angle between the normals // Now we need to determine, if the angle btw two triangles is less than Pi or // more than Pi. To do this we check, // if the point P4 lies in the halfspace given by trianlge P1P2P3 and the // normal to this triangle. If yes, we have // angle less than Pi, if not, we have angle more than Pi. // General equation of the plane is n_x*x + n_y*y + n_z*z + d = 0 where // (n_x,n_y,n_z) is the normal to the plane. // Point P1 lies in the plane, therefore d = -(n_x*P1_x + n_y*P1_y + n_z*P1_z) // Point P4 lies in the halfspace given by normal iff n_x*P4_x + n_y*P4_y + // n_z*P4_z + d >= 0 tmp11 = -(normal1[0] * P1[0] + normal1[1] * P1[1] + normal1[2] * P1[2]); if (normal1[0] * P4[0] + normal1[1] * P4[1] + normal1[2] * P4[2] + tmp11 < 0) phi = 2 * M_PI - phi; return phi; }
Foam::label Foam::quadraticFitSnGradData::calcFit ( const List<point>& C, const label faci ) { vector idir(1,0,0); vector jdir(0,1,0); vector kdir(0,0,1); findFaceDirs(idir, jdir, kdir, mesh(), faci); scalarList wts(C.size(), scalar(1)); wts[0] = centralWeight_; wts[1] = centralWeight_; point p0 = mesh().faceCentres()[faci]; scalar scale = 0; // calculate the matrix of the polynomial components scalarRectangularMatrix B(C.size(), minSize_, scalar(0)); forAll(C, ip) { const point& p = C[ip]; scalar px = (p - p0)&idir; scalar py = (p - p0)&jdir; #ifdef SPHERICAL_GEOMETRY scalar pz = mag(p) - mag(p0); #else scalar pz = (p - p0)&kdir; #endif if (ip == 0) scale = max(max(mag(px), mag(py)), mag(pz)); px /= scale; py /= scale; pz /= scale; label is = 0; B[ip][is++] = wts[0]*wts[ip]; B[ip][is++] = wts[0]*wts[ip]*px; B[ip][is++] = wts[ip]*sqr(px); if (dim_ >= 2) { B[ip][is++] = wts[ip]*py; B[ip][is++] = wts[ip]*px*py; B[ip][is++] = wts[ip]*sqr(py); } if (dim_ == 3) { B[ip][is++] = wts[ip]*pz; B[ip][is++] = wts[ip]*px*pz; //B[ip][is++] = wts[ip]*py*pz; B[ip][is++] = wts[ip]*sqr(pz); } } // Set the fit label stencilSize = C.size(); fit_[faci].setSize(stencilSize); scalarList singVals(minSize_); label nSVDzeros = 0; const scalar deltaCoeff = mesh().deltaCoeffs()[faci]; bool goodFit = false; for (int iIt = 0; iIt < 10 && !goodFit; iIt++) { SVD svd(B, SMALL); scalar fit0 = wts[0]*wts[0]*svd.VSinvUt()[1][0]/scale; scalar fit1 = wts[0]*wts[1]*svd.VSinvUt()[1][1]/scale; goodFit = fit0 < 0 && fit1 > 0 && mag(fit0 + deltaCoeff) < 0.5*deltaCoeff && mag(fit1 - deltaCoeff) < 0.5*deltaCoeff; if (goodFit) { fit_[faci][0] = fit0; fit_[faci][1] = fit1; for (label i = 2; i < stencilSize; i++) { fit_[faci][i] = wts[0]*wts[i]*svd.VSinvUt()[1][i]/scale; } singVals = svd.S(); nSVDzeros = svd.nZeros(); } else // (not good fit so increase weight in the centre and for linear) { wts[0] *= 10; wts[1] *= 10; for (label i = 0; i < B.n(); i++) { B[i][0] *= 10; B[i][1] *= 10; } for (label j = 0; j < B.m(); j++) { B[0][j] *= 10; B[1][j] *= 10; } } } if (goodFit) { // remove the uncorrected snGradScheme coefficients fit_[faci][0] += deltaCoeff; fit_[faci][1] -= deltaCoeff; } else { Pout<< "quadratifFitSnGradData could not fit face " << faci << " fit_[faci][0] = " << fit_[faci][0] << " fit_[faci][1] = " << fit_[faci][1] << " deltaCoeff = " << deltaCoeff << endl; fit_[faci] = 0; } return minSize_ - nSVDzeros; }
Vector3 Vector3::operator*(float value) const { return scalar(value); }
Foam::quadraticFitSnGradData::quadraticFitSnGradData ( const fvMesh& mesh, const scalar cWeight ) : MeshObject<fvMesh, quadraticFitSnGradData>(mesh), centralWeight_(cWeight), #ifdef SPHERICAL_GEOMETRY dim_(2), #else dim_(mesh.nGeometricD()), #endif minSize_ ( dim_ == 1 ? 3 : dim_ == 2 ? 6 : dim_ == 3 ? 9 : 0 ), stencil_(mesh), fit_(mesh.nInternalFaces()) { if (debug) { Info<< "Contructing quadraticFitSnGradData" << endl; } // check input if (centralWeight_ < 1 - SMALL) { FatalErrorIn("quadraticFitSnGradData::quadraticFitSnGradData") << "centralWeight requested = " << centralWeight_ << " should not be less than one" << exit(FatalError); } if (minSize_ == 0) { FatalErrorIn("quadraticFitSnGradData") << " dimension must be 1,2 or 3, not" << dim_ << exit(FatalError); } // store the polynomial size for each face to write out surfaceScalarField snGradPolySize ( IOobject ( "quadraticFitSnGradPolySize", "constant", mesh, IOobject::NO_READ, IOobject::NO_WRITE ), mesh, dimensionedScalar("quadraticFitSnGradPolySize", dimless, scalar(0)) ); // Get the cell/face centres in stencil order. // Centred face stencils no good for triangles of tets. Need bigger stencils List<List<point> > stencilPoints(stencil_.stencil().size()); stencil_.collectData ( mesh.C(), stencilPoints ); // find the fit coefficients for every face in the mesh for (label faci = 0; faci < mesh.nInternalFaces(); faci++) { snGradPolySize[faci] = calcFit(stencilPoints[faci], faci); } if (debug) { snGradPolySize.write(); Info<< "quadraticFitSnGradData::quadraticFitSnGradData() :" << "Finished constructing polynomialFit data" << endl; } }
void GidaspowDrag::setForce() const { if (scaleDia_ > 1) Info << "Gidaspow using scale = " << scaleDia_ << endl; else if (particleCloud_.cg() > 1){ scaleDia_=particleCloud_.cg(); Info << "Gidaspow using scale from liggghts cg = " << scaleDia_ << endl; } // get viscosity field #ifdef comp const volScalarField nufField = particleCloud_.turbulence().mu() / rho_; #else const volScalarField& nufField = particleCloud_.turbulence().nu(); #endif vector position(0,0,0); scalar voidfraction(1); vector Ufluid(0,0,0); vector drag(0,0,0); label cellI=0; vector Us(0,0,0); vector Uturb(0,0,0); vector Ur(0,0,0); scalar ds(0); scalar nuf(0); scalar rho(0); scalar magUr(0); scalar Rep(0); scalar Vs(0); scalar localPhiP(0); scalar CdMagUrLag(0); //Cd of the very particle scalar KslLag(0); //momentum exchange of the very particle (per unit volume) scalar betaP(0); //momentum exchange of the very particle interpolationCellPoint<scalar> voidfractionInterpolator_(voidfraction_); interpolationCellPoint<vector> UInterpolator_(U_); #include "setupProbeModel.H" for(int index = 0;index < particleCloud_.numberOfParticles(); ++index) { //if(mask[index][0]) //{ cellI = particleCloud_.cellIDs()[index][0]; drag = vector(0,0,0); betaP = 0; Vs = 0; Ufluid =vector(0,0,0); voidfraction=0; if (cellI > -1) // particle Found { position = particleCloud_.position(index); if(interpolation_) { //position = particleCloud_.position(index); voidfraction = voidfractionInterpolator_.interpolate(position,cellI); Ufluid = UInterpolator_.interpolate(position,cellI); //Ensure interpolated void fraction to be meaningful // Info << " --> voidfraction: " << voidfraction << endl; if(voidfraction>1.00) voidfraction = 1.0; if(voidfraction<0.10) voidfraction = 0.10; } else { voidfraction = voidfraction_[cellI]; Ufluid = U_[cellI]; } Us = particleCloud_.velocity(index); Ur = Ufluid-Us; //accounting for turbulent dispersion if(particleCloud_.dispersionM().isActive()) { Uturb=particleCloud_.fluidTurbVel(index); Ur=(Ufluid+Uturb)-Us; } magUr = mag(Ur); ds = 2*particleCloud_.radius(index)*phi_; rho = rho_[cellI]; nuf = nufField[cellI]; Rep=0.0; localPhiP = 1.0f-voidfraction+SMALL; Vs = ds*ds*ds*M_PI/6; //Compute specific drag coefficient (i.e., Force per unit slip velocity and per m³ SUSPENSION) //Wen and Yu, 1966 if(voidfraction > 0.8) //dilute { Rep=ds/scaleDia_*voidfraction*magUr/nuf; CdMagUrLag = (24.0*nuf/(ds/scaleDia_*voidfraction)) //1/magUr missing here, but compensated in expression for KslLag! *(scalar(1)+0.15*Foam::pow(Rep, 0.687)); KslLag = 0.75*( rho*localPhiP*voidfraction*CdMagUrLag / (ds/scaleDia_*Foam::pow(voidfraction,2.65)) ); } //Ergun, 1952 else //dense { KslLag = (150*Foam::pow(localPhiP,2)*nuf*rho)/ (voidfraction*ds/scaleDia_*ds/scaleDia_+SMALL) + (1.75*(localPhiP) * magUr * rho)/ ((ds/scaleDia_)); } // calc particle's drag coefficient (i.e., Force per unit slip velocity and per m³ PARTICLE) betaP = KslLag / localPhiP; // calc particle's drag drag = Vs * betaP * Ur * scaleDrag_; if (modelType_=="B") drag /= voidfraction; if(verbose_ && index >=0 && index <1) { Pout << " "<< endl; Pout << "Gidaspow drag force verbose: " << endl; Pout << "magUr = " << magUr << endl; Pout << "localPhiP = " << localPhiP << endl; Pout << "CdMagUrLag = " << CdMagUrLag << endl; Pout << "treatExplicit_ = " << treatExplicit_ << endl; Pout << "implDEM_ = " << implDEM_ << endl; Pout << "modelType_ = " << modelType_ << endl; Pout << "KslLag = " << KslLag << endl; Pout << "cellI = " << cellI << endl; Pout << "index = " << index << endl; Pout << "Ufluid = " << Ufluid << endl; Pout << "Uturb = " << Uturb << endl; Pout << "Us = " << Us << endl; Pout << "Ur = " << Ur << endl; Pout << "Vs = " << Vs << endl; Pout << "ds = " << ds << endl; Pout << "ds/scale = " << ds/scaleDia_ << endl; Pout << "phi = " << phi_ << endl; Pout << "rho = " << rho << endl; Pout << "nuf = " << nuf << endl; Pout << "voidfraction = " << voidfraction << endl; Pout << "Rep = " << Rep << endl; Pout << "localPhiP = " << localPhiP << endl; Pout << "betaP = " << betaP << endl; Pout << "drag = " << drag << endl; Pout << "position = " << position << endl; Pout << " "<< endl; } //Set value fields and write the probe if(probeIt_) { #include "setupProbeModelfields.H" vValues.append(drag); //first entry must the be the force vValues.append(Ur); sValues.append(Rep); sValues.append(betaP); sValues.append(voidfraction); particleCloud_.probeM().writeProbe(index, sValues, vValues); } } // set force on particle //treatExplicit_ = false by default if(treatExplicit_) for(int j=0;j<3;j++) expForces()[index][j] += drag[j]; else for(int j=0;j<3;j++) impForces()[index][j] += drag[j]; // set Cd //implDEM_ = false by default if(implDEM_) { for(int j=0;j<3;j++) fluidVel()[index][j]=Ufluid[j]; if (modelType_=="B" && cellI > -1) Cds()[index][0] = Vs*betaP/voidfraction*scaleDrag_; else Cds()[index][0] = Vs*betaP*scaleDrag_; }else{ for(int j=0;j<3;j++) DEMForces()[index][j] += drag[j]; } //}// end if mask }// end loop particles }
int calc_radial_density_map (int xbins,int ybins,int thetabins,double xrange,double yrange, double axis[3], double center[3], IntList *beadids, DoubleList *density_map, DoubleList *density_profile) { int i,j,t; int pi,bi; int nbeadtypes; int beadcount; double vectprod[3]; double pvector[3]; double xdist,ydist,rdist,xav,yav,theta; double xbinwidth,ybinwidth,binvolume; double thetabinwidth; double *thetaradii; int *thetacounts; int xindex,yindex,tindex; xbinwidth = xrange/(double)(xbins); ybinwidth = yrange/(double)(ybins); nbeadtypes = beadids->n; /* Update particles */ updatePartCfg(WITHOUT_BONDS); /*Make sure particles are folded */ for (i = 0 ; i < n_part ; i++) { fold_coordinate(partCfg[i].r.p,partCfg[i].m.v,partCfg[i].l.i,0); fold_coordinate(partCfg[i].r.p,partCfg[i].m.v,partCfg[i].l.i,1); fold_coordinate(partCfg[i].r.p,partCfg[i].m.v,partCfg[i].l.i,2); } beadcount = 0; xav = 0.0; yav = 0.0; for ( pi = 0 ; pi < n_part ; pi++ ) { for ( bi = 0 ; bi < nbeadtypes ; bi++ ) { if ( beadids->e[bi] == partCfg[pi].p.type ) { /* Find the vector from the point to the center */ vecsub(center,partCfg[pi].r.p,pvector); /* Work out x and y coordinates with respect to rotation axis */ /* Find the minimum distance of the point from the axis */ vector_product(axis,pvector,vectprod); xdist = sqrt(sqrlen(vectprod)/sqrlen(axis)); /* Find the projection of the vector from the point to the center onto the axis vector */ ydist = scalar(axis,pvector)/sqrt(sqrlen(axis)); /* Work out relevant indices for x and y */ xindex = (int)(floor(xdist/xbinwidth)); yindex = (int)(floor((ydist+yrange*0.5)/ybinwidth)); /* printf("x %d y %d \n",xindex,yindex); printf("p %f %f %f \n",partCfg[pi].r.p[0],partCfg[pi].r.p[1],partCfg[pi].r.p[2]); printf("pvec %f %f %f \n",pvector[0],pvector[1],pvector[2]); printf("axis %f %f %f \n",axis[0],axis[1],axis[2]); printf("dists %f %f \n",xdist,ydist); fflush(stdout); */ /* Check array bounds */ if ( (xindex < xbins && xindex > 0) && (yindex < ybins && yindex > 0) ) { density_map[bi].e[ybins*xindex+yindex] += 1; xav += xdist; yav += ydist; beadcount += 1; } else { // fprintf(stderr,"ERROR: outside array bounds in calc_radial_density_map"); fflush(NULL); errexit(); } } } } /* Now turn counts into densities for the density map */ for ( bi = 0 ; bi < nbeadtypes ; bi++ ) { for ( i = 0 ; i < xbins ; i++ ) { /* All bins are cylinders and therefore constant in yindex */ binvolume = PI*(2*i*xbinwidth + xbinwidth*xbinwidth)*yrange; for ( j = 0 ; j < ybins ; j++ ) { density_map[bi].e[ybins*i+j] /= binvolume; } } } /* if required calculate the theta density profile */ if ( thetabins > 0 ) { /* Convert the center to an output of the density center */ xav = xav/(double)(beadcount); yav = yav/(double)(beadcount); thetabinwidth = 2*PI/(double)(thetabins); thetaradii = (double*)malloc(thetabins*nbeadtypes*sizeof(double)); thetacounts = (int*)malloc(thetabins*nbeadtypes*sizeof(int)); for ( bi = 0 ; bi < nbeadtypes ; bi++ ) { for ( t = 0 ; t < thetabins ; t++ ) { thetaradii[bi*thetabins+t] = 0.0; thetacounts[bi*thetabins+t] = 0.0; } } /* Maybe there is a nicer way to do this but now I will just repeat the loop over all particles */ for ( pi = 0 ; pi < n_part ; pi++ ) { for ( bi = 0 ; bi < nbeadtypes ; bi++ ) { if ( beadids->e[bi] == partCfg[pi].p.type ) { vecsub(center,partCfg[pi].r.p,pvector); vector_product(axis,pvector,vectprod); xdist = sqrt(sqrlen(vectprod)/sqrlen(axis)); ydist = scalar(axis,pvector)/sqrt(sqrlen(axis)); /* Center the coordinates */ xdist = xdist - xav; ydist = ydist - yav; rdist = sqrt(xdist*xdist+ydist*ydist); if ( ydist >= 0 ) { theta = acos(xdist/rdist); } else { theta = 2*PI-acos(xdist/rdist); } tindex = (int)(floor(theta/thetabinwidth)); thetaradii[bi*thetabins+tindex] += xdist + xav; thetacounts[bi*thetabins+tindex] += 1; if ( tindex >= thetabins ) { fprintf(stderr,"ERROR: outside density_profile array bounds in calc_radial_density_map"); fflush(NULL); errexit(); } else { density_profile[bi].e[tindex] += 1; } } } } /* normalize the theta densities*/ for ( bi = 0 ; bi < nbeadtypes ; bi++ ) { for ( t = 0 ; t < thetabins ; t++ ) { rdist = thetaradii[bi*thetabins+t]/(double)(thetacounts[bi*thetabins+t]); density_profile[bi].e[t] /= rdist*rdist; } } free(thetaradii); free(thetacounts); } // printf("done \n"); return ES_OK; }
void SHF::breakupParcel ( parcel& p, const scalar deltaT, const vector& vel, const liquidMixture& fuels ) const { label celli = p.cell(); scalar T = p.T(); scalar pc = spray_.p()[celli]; scalar sigma = fuels.sigma(pc, T, p.X()); scalar rhoLiquid = fuels.rho(pc, T, p.X()); scalar muLiquid = fuels.mu(pc, T, p.X()); scalar rhoGas = spray_.rho()[celli]; scalar weGas = p.We(vel, rhoGas, sigma); scalar weLiquid = p.We(vel, rhoLiquid, sigma); // correct the Reynolds number. Reitz is using radius instead of diameter scalar reLiquid = p.Re(rhoLiquid, vel, muLiquid); scalar ohnesorge = sqrt(weLiquid)/(reLiquid + VSMALL); vector acceleration = p.Urel(vel)/p.tMom(); vector trajectory = p.U()/mag(p.U()); vector vRel = p.Urel(vel); scalar weGasCorr = weGas/(1.0 + weCorrCoeff_ * ohnesorge); // droplet deformation characteristic time scalar tChar = p.d()/mag(vRel)*sqrt(rhoLiquid/rhoGas); scalar tFirst = cInit_ * tChar; scalar tSecond = 0; scalar tCharSecond = 0; bool bag = false; bool multimode = false; bool shear = false; bool success = false; // updating the droplet characteristic time p.ct() += deltaT; if(weGas > weConst_) { if(weGas < weCrit1_) { tCharSecond = c1_*pow((weGas - weConst_),cExp1_); } else if(weGas >= weCrit1_ && weGas <= weCrit2_) { tCharSecond = c2_*pow((weGas - weConst_),cExp2_); } else { tCharSecond = c3_*pow((weGas - weConst_),cExp3_); } } scalar weC = weBuCrit_*(1.0+ohnCoeffCrit_*pow(ohnesorge,ohnExpCrit_)); scalar weB = weBuBag_*(1.0+ohnCoeffBag_*pow(ohnesorge, ohnExpBag_)); scalar weMM = weBuMM_*(1.0+ohnCoeffMM_*pow(ohnesorge, ohnExpMM_)); if(weGas > weC && weGas < weB) { bag = true; } if(weGas >= weB && weGas <= weMM) { multimode = true; } if(weGas > weMM) { shear = true; } tSecond = tCharSecond * tChar; scalar tBreakUP = tFirst + tSecond; if(p.ct() > tBreakUP) { scalar d32 = coeffD_*p.d()*pow(ohnesorge,onExpD_)*pow(weGasCorr,weExpD_); if(bag || multimode) { scalar d05 = d32Coeff_ * d32; scalar x = 0.0; scalar y = 0.0; scalar d = 0.0; while(!success) { x = cDmaxBM_*rndGen_.scalar01(); d = sqr(x)*d05; y = rndGen_.scalar01(); scalar p = x/(2.0*sqrt(2.0*mathematicalConstant::pi)*sigma_)*exp(-0.5*sqr((x-mu_)/sigma_)); if (y<p) { success = true; } } p.d() = d; p.ct() = 0.0; } if(shear) { scalar dC = weConst_*sigma/(rhoGas*sqr(mag(vRel))); scalar d32Red = 4.0*(d32 * dC)/(5.0 * dC - d32); scalar initMass = p.m(); scalar d05 = d32Coeff_ * d32Red; scalar x = 0.0; scalar y = 0.0; scalar d = 0.0; while(!success) { x = cDmaxS_*rndGen_.scalar01(); d = sqr(x)*d05; y = rndGen_.scalar01(); scalar p = x/(2.0*sqrt(2.0*mathematicalConstant::pi)*sigma_)*exp(-0.5*sqr((x-mu_)/sigma_)); if (y<p) { success = true; } } p.d() = dC; p.m() = corePerc_ * initMass; spray_.addParticle ( new parcel ( spray_, p.position(), p.cell(), p.n(), d, p.T(), (1.0 - corePerc_)* initMass, 0.0, 0.0, 0.0, -GREAT, p.tTurb(), 0.0, scalar(p.injector()), p.U(), p.Uturb(), p.X(), p.fuelNames() ) ); p.ct() = 0.0; } } }
double angleTo(Vector2D * rh) { return acos(scalar(rh) / (norm() * rh->norm())); }