int main()
{
MarchingCubeGridf phi(1,1,1);
std::ifstream phifile("cube.phi");
phi.read(phifile);
Meshf mesh;
phi.populateMesh(mesh,0);
std::cout << mesh.vertices.size() << std::endl;
std::cout << mesh.edges.size() << std::endl;
std::cout << mesh.faces.size() << std::endl;
std::ofstream out("output.obj");
MeshIOUtils::OBJParser<NumericalTraitsXf> parser(&mesh);
parser.write(out);
}
//**********************************************************************
PHX_EVALUATE_FIELDS(FEInterpolation,cell_data)
{
std::vector<Element_Linear2D>::iterator cell_it = cell_data.begin;
// Loop over number of cells
for (std::size_t cell = 0; cell < cell_data.num_cells; ++cell) {
const shards::Array<double,shards::NaturalOrder,QuadPoint,Node>& phi =
cell_it->basisFunctions();
const shards::Array<double,shards::NaturalOrder,QuadPoint,Node,Dim>&
grad_phi = cell_it->basisFunctionGradientsRealSpace();
// Loop over quad points of cell
for (int qp = 0; qp < num_qp; ++qp) {
val_qp(cell,qp) = 0.0;
for (int dim = 0; dim < num_dim; ++dim)
val_grad_qp(cell,qp,dim) = 0.0;
// Sum nodal contributions to qp
for (int node = 0; node < num_nodes; ++node) {
val_qp(cell,qp) += phi(qp,node) * val_node(cell,node);
for (int dim = 0; dim < num_dim; ++dim)
val_grad_qp(cell,qp,dim) +=
grad_phi(qp,node,dim) * val_node(cell,node);
}
}
++cell_it;
}
// std::cout << "FEINterpolation: val_node" << std::endl;
// val_node.print(std::cout,true);
// std::cout << "FEINterpolation: val_qp" << std::endl;
// val_qp.print(std::cout,true);
// std::cout << "FEINterpolation: val_grad_qp" << std::endl;
// val_grad_qp.print(std::cout,true);
}
Foam::tmp<Foam::volScalarField>
Foam::diameterModels::IATEsources::randomCoalescence::R() const
{
tmp<volScalarField> tR
(
new volScalarField
(
IOobject
(
"R",
iate_.phase().time().timeName(),
iate_.phase().mesh()
),
iate_.phase().mesh(),
dimensionedScalar("R", dimless/dimTime, 0)
)
);
volScalarField R = tR();
scalar Crc = Crc_.value();
scalar C = C_.value();
scalar alphaMax = alphaMax_.value();
volScalarField Ut(this->Ut());
const volScalarField& alpha = phase();
const volScalarField& kappai = iate_.kappai();
scalar cbrtAlphaMax = cbrt(alphaMax);
forAll(R, celli)
{
if (alpha[celli] < alphaMax - SMALL)
{
scalar cbrtAlphaMaxMAlpha = cbrtAlphaMax - cbrt(alpha[celli]);
R[celli] =
(-12)*phi()*kappai[celli]*alpha[celli]
*Crc
*Ut[celli]
*(1 - exp(-C*cbrt(alpha[celli]*alphaMax)/cbrtAlphaMaxMAlpha))
/(cbrtAlphaMax*cbrtAlphaMaxMAlpha);
}
}
return tR;
}
FnMap minimizeLength(const FnWord &u, const Basis &basis)
{
/* Returns an automorphism phi such that phi(u) has minimal
length. */
int r = basis.getRank();
FnMap phi(r);
if (u == Id) return phi;
if (u.length() == 1) return phi;
int old_norm,new_norm;
FnWord u_min(u),tmp;
FnMap whAuto(r);
QList<WhiteheadData> whAutos = whiteheadAutos(basis);
QListIterator<WhiteheadData> move(whAutos);
bool reduced_norm = true;
while (reduced_norm) {
old_norm = u_min.length();
new_norm = old_norm;
move.toFront();
while (old_norm <= new_norm && move.hasNext()) {
whAuto = whitehead(move.next(),basis);
tmp = whAuto(u_min);
new_norm = tmp.length();
}
if (new_norm < old_norm) {
u_min = tmp;
phi = whAuto*phi;
} else
reduced_norm = false;
} // end while (reduced_norm)
// now u_min = phi(u)
return phi;
}
void Foam::Leonov::correct()
{
// Velocity gradient tensor
volTensorField L = fvc::grad(U());
// Convected derivate term
volTensorField C = sigma_ & L;
// Twice the rate of deformation tensor
volSymmTensorField twoD = twoSymm(L);
// Two phase transport properties treatment
volScalarField alpha1f = min(max(alpha(), scalar(0)), scalar(1));
volScalarField lambda = alpha1f*lambda1_ + (scalar(1) - alpha1f)*lambda2_;
volScalarField etaP = alpha1f*etaP1_ + (scalar(1) - alpha1f)*etaP2_;
// Stress transport equation
fvSymmTensorMatrix sigmaEqn
(
fvm::ddt(sigma_)
+ fvm::div(phi(), sigma_)
==
twoSymm(C)
- 1/etaP/2*(symm(sigma_ & sigma_) - Foam::pow((etaP/lambda), 2)*I_)
+ fvm::Sp
(
1/etaP/6*
(
tr(sigma_)
- Foam::pow(etaP/lambda,2) * tr(inv(sigma_))
),
sigma_
)
);
sigmaEqn.relax();
sigmaEqn.solve();
// Viscoelastic stress
tau_ = sigma_ - etaP/lambda*I_;
}
void getError(LevelData<double, 1> & a_error,
double & a_maxError,
const double & a_dx)
{
BoxLayout layout = a_error.getBoxLayout();
LevelData<double, 1> phi(layout, s_nghost);
LevelData<double, 1> lphcalc(layout, 0);
LevelData<double, 1> lphexac(layout, 0);
// cout << "initializing phi to sum_dir(sin 2*pi*xdir)" << endl;
initialize(phi,lphexac, a_dx);
//set ghost cells of phi
phi.exchange();
// dumpLevelRDA(&phi);
Stencil<double> laplace;
setStencil(laplace, a_dx);
//apply stencil operator independently on each box
a_maxError = 0;
for(BLIterator blit(layout); blit != blit.end(); ++blit)
{
RectMDArray<double>& phiex = phi[*blit];
RectMDArray<double>& lphca = lphcalc[*blit];
RectMDArray<double>& lphex = lphexac[*blit];
RectMDArray<double>& error = a_error[*blit];
//apply is set as an increment so need to set this to zero initially
lphca.setVal(0.);
Box bxdst=layout[*blit];
Stencil<double>::apply(laplace, phiex, lphca, bxdst);
//error = lphicalc -lphiexac
lphca.copyTo(error);
//here err holds lphi calc
double maxbox = forall_max(error, lphex, &errorF, bxdst);
a_maxError = max(maxbox, a_maxError);
}
}
///* Computation of Critical Rate in the Jamishidian decomposition, with the newton method to find zero of a function
static double Critical_Rate(ZCMarketData* ZCMarket, double r_initial, double periodicity, double option_maturity, double contract_maturity, double SwaptionFixedRate, double a, double sigma)
{
double previous,current;
int nbr_iterations;
const double precision = 0.000001;
current = r_initial;
nbr_iterations = 0;
do
{
nbr_iterations++;
previous =current;
current=current-phi(ZCMarket, current, periodicity, option_maturity, contract_maturity, SwaptionFixedRate, a, sigma);
} while((fabs(previous-current) > precision) && (nbr_iterations <= 50));
return current;
}
int main()
{
long long i,j;
boolean[0]=1;
boolean[1]=1;
for(i=2;i*i<55000;i++)
{
if(!boolean[i])
{
for(j=i*i;j<55000;j+=i)
{
boolean[j]=1;
}
}
}
int index=0;
for(i=2;i<55000;i++)
{
if(!boolean[i])
{
primes[index++]=i;
}
}
coprimes[0]=1;
long long global=1;
for(i=1;i<50000;i++)
{
coprimes[i]=2*phi(i+1);
}
long long input;
while(scanf("%lld",&input)==1 && input)
{
long long output=0;
for(i=input-1;i>=0;i--)
{
output+=coprimes[i];
}
printf("%lld\n",output);
}
return 0;
}
Euler(const Dcm<Type> & dcm) : Vector<Type, 3>()
{
Type phi_val = Type(atan2(dcm(2,1), dcm(2,2)));
Type theta_val = Type(asin(-dcm(2,0)));
Type psi_val = Type(atan2(dcm(1,0), dcm(0,0)));
Type pi = Type(M_PI);
if (fabs(theta_val - pi/2) < 1.0e-3) {
phi_val = Type(0.0);
psi_val = Type(atan2(dcm(1,2), dcm(0,2)));
} else if (Type(fabs(theta_val + pi/2)) < Type(1.0e-3)) {
phi_val = Type(0.0);
psi_val = Type(atan2(-dcm(1,2), -dcm(0,2)));
}
phi() = phi_val;
theta() = theta_val;
psi() = psi_val;
}
void NSForchheimerTerm<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
normV(cell,qp) = 0.0;
for (std::size_t i=0; i < numDims; ++i) {
normV(cell,qp) += V(cell,qp,i)*V(cell,qp,i);
}
if (normV(cell,qp) > 0)
normV(cell,qp) = std::sqrt(normV(cell,qp));
else
normV(cell,qp) = 0.0;
for (std::size_t i=0; i < numDims; ++i) {
ForchTerm(cell,qp,i) = phi(cell,qp)*rho(cell,qp)*F(cell,qp)*normV(cell,qp)*V(cell,qp,i)/std::sqrt(K(cell,qp));
}
}
}
}
void mk_array_instantiation::instantiate_rule(const rule& r, rule_set & dest)
{
//Reset everything
selects.reset();
eq_classes.reset();
cnt = src_manager->get_counter().get_max_rule_var(r)+1;
done_selects.reset();
ownership.reset();
expr_ref_vector phi(m);
expr_ref_vector preds(m);
expr_ref new_head = create_head(to_app(r.get_head()));
unsigned nb_predicates = r.get_uninterpreted_tail_size();
unsigned tail_size = r.get_tail_size();
for(unsigned i=0;i<nb_predicates;i++)
{
preds.push_back(r.get_tail(i));
}
for(unsigned i=nb_predicates;i<tail_size;i++)
{
phi.push_back(r.get_tail(i));
}
//Retrieve selects
for(unsigned i=0;i<phi.size();i++)
retrieve_selects(phi[i].get());
//Rewrite the predicates
expr_ref_vector new_tail(m);
for(unsigned i=0;i<preds.size();i++)
{
new_tail.append(instantiate_pred(to_app(preds[i].get())));
}
new_tail.append(phi);
for(obj_map<expr, var*>::iterator it = done_selects.begin(); it!=done_selects.end(); ++it)
{
expr_ref tmp(m);
tmp = &it->get_key();
new_tail.push_back(m.mk_eq(it->get_value(), tmp));
}
proof_ref pr(m);
src_manager->mk_rule(m.mk_implies(m.mk_and(new_tail.size(), new_tail.c_ptr()), new_head), pr, dest, r.name());
}
void Feta_PTT::correct()
{
// Velocity gradient tensor
volTensorField L = fvc::grad( U() );
// Convected derivate term
volTensorField C = tau_ & L;
// Twice the rate of deformation tensor
volSymmTensorField twoD = twoSymm( L );
// Two phase transport properties treatment
alpha1f_ = min(max(alpha(), scalar(0)), scalar(1));
// etaP effective
etaPEff_ = (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_);
// lambda effective
lambdaEff_ = (lambda1_ / (scalar(1) + epsilon1_*lambda1_*tr(tau_) / etaP1_) )*alpha1f_ + (lambda2_ / (scalar(1) + epsilon2_*lambda2_*tr(tau_) / etaP2_) )*(scalar(1) - alpha1f_);
volScalarField epsilon = alpha1f_*epsilon1_ + (scalar(1) - alpha1f_)*epsilon2_;
volScalarField zeta = alpha1f_*zeta1_ + (scalar(1) - alpha1f_)*zeta2_;
// Stress transport equation
tmp<fvSymmTensorMatrix> tauEqn
(
fvm::ddt(lambdaEff_, tau_)
+ lambdaEff_ * fvm::div(phi(), tau_)
==
etaPEff_ * twoD
+ lambdaEff_ * twoSymm( C )
- zeta * lambdaEff_ /2* symm( (tau_ & twoD) + (twoD & tau_) )
//add "twoSymm"(...), by Martin R. Du, [email protected]
//replace "*twoSymm" with "*symm", Martin R. Du, 2015/08/08
- fvm::Sp( epsilon * lambdaEff_ / etaPEff_ * tr(tau_) + 1, tau_ )
);
tauEqn().relax();
solve(tauEqn);
}
/***********************************************************************//**
* @brief Sum effective area multiplied by livetime over zenith angles
*
* @param[in] dir True sky direction.
* @param[in] energy True photon energy.
* @param[in] offset Offset from true direction (deg).
* @param[in] psf Point spread function.
* @param[in] aeff Effective area.
*
* Computes
* \f[\sum_{\cos \theta} T_{\rm live}(\cos \theta)
* PSF(\log E, \delta, \cos \theta) A_{\rm eff}(\cos \theta, \phi)\f]
* where
* \f$T_{\rm live}(\cos \theta)\f$ is the livetime as a function of the
* cosine of the zenith angle, and
* \f$PSF(\log E, \delta, \cos \theta)\f$ is the point spread function that
* depends on
* the log10 of the energy (in MeV),
* the offset angle from the true direction (in degrees), and
* the cosine of the zenith angle, and
* \f$A_{\rm eff}(\cos \theta, \phi)\f$ is the effective area that depends
* on the cosine of the zenith angle and (optionally) of the azimuth angle.
***************************************************************************/
double GLATLtCubeMap::operator()(const GSkyDir& dir, const GEnergy& energy,
const double& offset, const GLATPsf& psf,
const GLATAeff& aeff) const
{
// Get map index
int pixel = m_map.dir2pix(dir);
// Initialise sum
double sum = 0.0;
// Circumvent const correctness
GLATPsf* fpsf = const_cast<GLATPsf*>(&psf);
GLATAeff* faeff = const_cast<GLATAeff*>(&aeff);
// Get log10 of energy
double logE = energy.log10MeV();
// If livetime cube and response have phi dependence then sum over
// zenith and azimuth. Note that the map index starts with m_num_ctheta
// as the first m_num_ctheta maps correspond to an evaluation without
// any phi-dependence.
if (has_phi() && aeff.has_phi()) {
for (int iphi = 0, i = m_num_ctheta; iphi < m_num_phi; ++iphi) {
double p = phi(iphi);
for (int itheta = 0; itheta < m_num_ctheta; ++itheta, ++i) {
sum += m_map(pixel, i) * (*faeff)(logE, costheta(i), p) *
(*fpsf)(offset, logE, costheta(i));
}
}
}
// ... otherwise sum only over zenith angle
else {
for (int i = 0; i < m_num_ctheta; ++i) {
sum += m_map(pixel, i) * (*faeff)(logE, costheta(i)) *
(*fpsf)(offset, logE, costheta(i));
}
}
// Return sum
return sum;
}
void FENE_P::correct()
{
// Velocity gradient tensor
volTensorField L = fvc::grad(U());
// Convected derivate term
volTensorField C = tau_ & L;
// Twice the rate of deformation tensor
volSymmTensorField twoD = twoSymm(L);
// Two phase transport properties treatment
volScalarField alpha1f =
min(max(alpha(),scalar(0)),scalar(1));
volScalarField lambda =
alpha1f*lambda1_ + (scalar(1) - alpha1f)*lambda2_;
volScalarField etaP =
alpha1f*etaP1_ + (scalar(1) - alpha1f)*etaP2_;
volScalarField Lquad =
alpha1f*Lquad1_ + (scalar(1) - alpha1f)*Lquad2_;
// Stress transport equation
tmp<fvSymmTensorMatrix> tauEqn
(
fvm::ddt(lambda, tau_)
+ lambda * fvm::div(phi(), tau_)
==
( 1 / (1 - 3/Lquad) ) * etaP * twoD
+ lambda * twoSymm( C )
- fvm::Sp
(
1 + (3/(1 - 3/Lquad) + lambda*tr(tau_)/etaP )/Lquad,
tau_
)
);
tauEqn().relax();
solve(tauEqn);
}
void ContinuumMechanicsNeumannBcsAssembler<DIM>::AssembleOnBoundaryElement(BoundaryElement<DIM-1,DIM>& rBoundaryElement,
c_vector<double,STENCIL_SIZE>& rBelem,
unsigned boundaryConditionIndex)
{
rBelem.clear();
c_vector<double, DIM> weighted_direction;
double jacobian_determinant;
mpMesh->GetWeightedDirectionForBoundaryElement(rBoundaryElement.GetIndex(), weighted_direction, jacobian_determinant);
c_vector<double,NUM_NODES_PER_ELEMENT> phi;
for (unsigned quad_index=0; quad_index<mpQuadRule->GetNumQuadPoints(); quad_index++)
{
double wJ = jacobian_determinant * mpQuadRule->GetWeight(quad_index);
const ChastePoint<DIM-1>& quad_point = mpQuadRule->rGetQuadPoint(quad_index);
QuadraticBasisFunction<DIM-1>::ComputeBasisFunctions(quad_point, phi);
c_vector<double,DIM> traction = zero_vector<double>(DIM);
switch (mpProblemDefinition->GetTractionBoundaryConditionType())
{
case ELEMENTWISE_TRACTION:
{
traction = mpProblemDefinition->rGetElementwiseTractions()[boundaryConditionIndex];
break;
}
default:
// Functional traction not implemented yet..
NEVER_REACHED;
}
for (unsigned index=0; index<NUM_NODES_PER_ELEMENT*DIM; index++)
{
unsigned spatial_dim = index%DIM;
unsigned node_index = (index-spatial_dim)/DIM;
assert(node_index < NUM_NODES_PER_ELEMENT);
rBelem(index) += traction(spatial_dim) * phi(node_index) * wJ;
}
}
}
/******************************************************************
* It computes a sum of a series of values, as needed by formula *
* 11.25 of "Inside Solid State Drives" book. It helps performing *
* Horizontal step of Log-Domain Belief Propagation algorithm. *
******************************************************************/
double log_bp_error_corrector::phi(double** R, int i, int j)
{
double result;
result = 0;
std::list<edge> edges = chk_nodes[j].get_edges();
std::list<edge>::iterator it;
for(it = edges.begin(); it != edges.end(); it++){
int l = (*it).get_dest().get_idx();
if(l != i){
result += phi(abs(R[l][j]));
}
}
return result;
}
void LevelSetViewerWidget::openFile(const QString & filename)
{
m_ready = false;
qWarning() << "Loading file: "<< filename;
if(m_obj){delete m_obj;}
std::ifstream in(filename.toStdString().c_str());
if(m_grid){delete m_grid;}
m_grid = new Gridf();
m_grid->read(in);
std::cout << m_grid->NI() << " " << m_grid->NJ() << " " << m_grid->NK() << std::endl;
MarchingSquaresGridf phi(*m_grid);
m_obj = new Mesh2f();
phi.populateMesh(*m_obj,0);
MeshUtils::normalize(*m_obj);
std::cout << m_obj->vertices.size() << std::endl;
std::cout << m_obj->faces.size() << std::endl;
sendBuffers();
}
inline Polynomial<eT>
polyfit(const eT* x, const eT* y, const uword length, const uword order)
{
const uword size = order + 1;
Col<eT> Q(size); //parameter to be estimated.
Q.fill(eT(0)); //initialized with zeros.
Col<eT> phi(size); //
Mat<eT> P = eye(size, size) * 1e6;
Col<eT> K;
Mat<eT> I = eye(size, size);
for(uword i = 0; i < length; ++i)
{
detail::gen_phi(phi, x[i]);
K = P * phi / (1 + as_scalar(phi.st() * P * phi)); //K(t) = P(t-1)*phi(t)*inv(I+phi'*P(t-1)*phi).
P = (I - K * phi.st()) * P; //P(t) = (I-K(t)*phi')*P(t-1).
Q = Q + K * (y[i] - as_scalar(phi.st() * Q)); //Q(t) = Q(t-1) + K(t)*(y(t)-phi'Q(t-1)).
}
return std::move(Polynomial<eT>(Q));
}
double PDPS::logpri()const{
const Mat & Nu(m_->Nu());
uint d = nrow(Nu);
Vec phi(d);
double ans=0;
for(uint i=0; i<d; ++i){
double a = sum(Nu.row(i));
if(a <=0) return BOOM::negative_infinity();
phi = Nu.row(i);
for(uint j=0; j<d; ++j) {
if(phi[j] < min_nu_) {
return BOOM::negative_infinity();
}
}
phi/=a;
ans += alpha_row_prior_[i]->logp(a);
ans += phi_row_prior_[i]->logp(phi);
ans -= (d-1) * log(a);
}
return ans;
}
/***********************************************************************//**
* @brief Sum function multiplied by livetime over zenith and azimuth angles
*
* @param[in] dir Sky direction.
* @param[in] fct Function to evaluate.
*
* Computes
* \f[\sum_{\cos \theta, \phi} T_{\rm live}(\cos \theta, \phi)
* f(\cos \theta, \phi)\f]
* where
* \f$T_{\rm live}(\cos \theta, \phi)\f$ is the livetime as a function of
* the cosine of the zenith and of the azimuth angle, and
* \f$f(\cos \theta, \phi)\f$ is a function that depends on the cosine of
* the zenith angle and of the azimuth angle.
* This method assumes that \f$T_{\rm live}(\cos \theta, \phi)\f$ is
* stored as a set of maps in a 2D array with \f$\cos \theta\f$ being the
* most rapidely varying parameter and with the first map starting at
* index m_num_ctheta (the first m_num_ctheta maps are the livetime cube
* maps without any \f$\phi\f$ dependence).
***************************************************************************/
double GLATLtCubeMap::operator()(const GSkyDir& dir, _ltcube_ctheta_phi fct) const
{
// Get map index
int pixel = m_map.dir2pix(dir);
// Initialise sum
double sum = 0.0;
// Loop over azimuth and zenith angles. Note that the map index starts
// with m_num_ctheta as the first m_num_ctheta maps correspond to an
// evaluation without any phi-dependence.
for (int iphi = 0, i = m_num_ctheta; iphi < m_num_phi; ++iphi) {
double p = phi(iphi);
for (int itheta = 0; itheta < m_num_ctheta; ++itheta, ++i) {
sum += m_map(pixel, i) * (*fct)(costheta(itheta), p);
}
}
// Return sum
return sum;
}
// for co-ordinates at box nn, ll, evaluates the value using
// coefficients at box n, l
// this function assumes that x is Vector.
double* FunctionAST::evaluate_at_box(int k, double* coeff, int n, int l, int nn, int ll, double* x)
{
int i;
double* p;
double coordinate;
double temp;
double* returnVector;
returnVector = Vector_initialize(NULL, 0, this->func->k+ADD_K);
for (i=0; i<this->func->k; i++)
{
coordinate = ((x[i] + ll) * (pow(2.0, n - nn))) - l;
p = Vector_initialize(phi(coordinate, this->func->k), 0, this->func->k);
temp = Vector_inner(coeff, p, this->func->k);
returnVector[i] = temp * sqrt(pow(2.0, n));
free(p);
}
return returnVector;
}
void oneEqEddy::correct(const tmp<volTensorField>& gradU)
{
GenEddyVisc::correct(gradU);
volScalarField G = 2.0*nuSgs_*magSqr(symm(gradU));
solve
(
fvm::ddt(k_)
+ fvm::div(phi(), k_)
- fvm::laplacian(DkEff(), k_)
==
G
- fvm::Sp(ce_*sqrt(k_)/delta(), k_)
);
bound(k_, k0());
nuSgs_ = ck_*sqrt(k_)*delta();
nuSgs_.correctBoundaryConditions();
}
int run(){
const int order_ = 20;
int numshape = (order_+1)*(order_+1)*(order_+1);
TPZVec<REAL> point(3,0.);
TPZVec<int> id(8);
int i;
for(i = 0; i< 8; i ++)
{
id[i] = i;
}
TPZVec<int> order(19);
for(i = 0; i< 19; i ++)
{
order[i] = order_;
}
TPZCompEl::SetgOrder(order_);
TPZVec<FADREAL> phi(numshape);
TPZFMatrix OldPhi(numshape,1), OldDPhi(3,numshape);
TPZFMatrix DiffPhi(numshape,1), DiffDPhi(3,numshape);
TPZShapeCube::ShapeCube(point, id, order, phi);
TPZShapeCube::ShapeCube(point, id, order, OldPhi, OldDPhi);
/*cout << "Calculated by Fad" << phi;
cout << "Old derivative method (phi)\n" << OldPhi;
cout << "Old derivative method (dPhi)\n" << OldDPhi;
shapeFAD::ExplodeDerivatives(phi, DiffPhi, DiffDPhi);
DiffPhi-=OldPhi;
DiffDPhi-=OldDPhi;*/
//cout << "FAD derivative method (phi)\n" << /*TPZFMatrix (OldPhi -*/ DiffPhi;
//cout << "FAD derivative method (dPhi)\n" <</* TPZFMatrix (OldDPhi -*/ DiffDPhi;
return 0;
}
void Foam::S_MDCPP::correct()
{
// Velocity gradient tensor
volTensorField L = fvc::grad(U());
// Convected derivate term
volTensorField C = tau_ & L;
// Twice the rate of deformation tensor
volSymmTensorField twoD = twoSymm(L);
// Lambda (Backbone stretch)
volScalarField Lambda =
Foam::sqrt(1 + tr(tau_)*lambdaOb_*(1 - zeta_)/3/etaP_);
// Auxiliary field
volScalarField aux = Foam::exp( 2/q_*(Lambda - 1));
// Extra function
volScalarField fTau =
aux*(2*lambdaOb_/lambdaOs_*(1 - 1/Lambda) + 1/Foam::sqr(Lambda));
// Stress transport equation
fvSymmTensorMatrix tauEqn
(
fvm::ddt(tau_)
+ fvm::div(phi(), tau_)
==
etaP_/lambdaOb_*twoD
+ twoSymm(C)
- zeta_/2*((tau_ & twoD) + (twoD & tau_))
- fvm::Sp(1/lambdaOb_*fTau, tau_)
- (
1/lambdaOb_*(etaP_/lambdaOb_/(1 - zeta_)*(fTau - aux)*I_)
)
);
tauEqn.relax();
tauEqn.solve();
}
void CD_Extended_Kalman_Filter::_rk4___prediction_FM(dcovector &Xp, dgematrix &p)
{
Continuous_Discrete_Model *m=dynamic_cast<Continuous_Discrete_Model *>(model);
dgematrix G = m->Diffusion_Function();
dgematrix Q=G*(m->Qw*t(G));
double delta = m->Ts;
dgematrix phi(p.m,p.n);
dcovector dx1, dx2, dx3, dx4;
dgematrix K1, K2, K3, K4;
dgematrix J1,J2,J3,J4;
dx1 = m->Drift_Function(M);
dx2 = m->Drift_Function(M + 0.5*delta *dx1);
dx3 = m->Drift_Function(M + 0.5*delta *dx2);
dx4 = m->Drift_Function(M + delta *dx3);
Xp= M + delta * (dx1+2.*dx2+2.*dx3+dx4)/6.;
J1 = m->J_Drift_Function(M);
J2 = m->J_Drift_Function(M + 0.5 * delta * dx1);
J3 = m->J_Drift_Function(M + 0.5 * delta * dx2);
J4 = m->J_Drift_Function(M + delta * dx3);
phi.identity();
K1 = J1 ;
K2 = J2 * (phi + 0.5*delta * K1);
K3 = J3 * (phi + 0.5*delta * K2);
K4 = J4 * (phi + delta * K3);
phi = phi + delta *(K1 + 2.*K2 + 2.*K3 + K4) / 6.;
p = phi *(R * t(phi)) + Q * delta;
}
obj applyCS(obj (*func)(obj, obj), obj v1, obj v2){
assert(!isVec(type(v2)));
if(isVec(type(v1))){
int len=size(v1);
obj rr = aArray(len);
for(int i=0; i<len; i++){
obj lt=ind(v1,i);
uar(rr).v[i] = call_fn(func, lt, v2);
release(lt);
}
return rr;
}
if(type(v1)==LIST){
list l=phi();
for(list l1=ul(v1); l1; l1=rest(l1)){
l = cons(call_fn(func, first(l1), v2), l);
}
return List2v(reverse(l));
}
assert(0);
return nil;
}
/** @brief Volumetric contribute with jacobian matrix */
void TPZPrimalPoisson::Contribute(TPZMaterialData &data,REAL weight,TPZFMatrix<STATE> &ek,TPZFMatrix<STATE> &ef){
TPZFNMatrix<220,REAL> &phi = data.phi;
TPZFNMatrix<660,REAL> &dphix = data.dphix;
TPZFNMatrix<15,STATE> &dpdx = data.dsol[0];
int nphi_p = phi.Rows();
TPZManVector<STATE,1> f(1,0.0);
TPZFMatrix<STATE> df;
if (this->HasForcingFunction()) {
this->fForcingFunction->Execute(data.x, f, df);
}
int dim = this->Dimension();
for (int ip = 0; ip < nphi_p; ip++) {
STATE dp_dot_dphi_i = 0.0;
for (int i = 0; i < dim; i++) {
dp_dot_dphi_i += dpdx[i]*dphix(i,ip);
}
ef(ip,0) += weight * (dp_dot_dphi_i - f[0] * phi(ip,0));
for (int jp = 0; jp < nphi_p; jp++) {
STATE dphi_j_dot_dphi_i = 0.0;
for (int i = 0; i < this->Dimension(); i++) {
dphi_j_dot_dphi_i += dphix(i,jp)*dphix(i,ip);
}
ek(ip,jp) += weight * dphi_j_dot_dphi_i;
}
}
}
double GMM<FittingType>::LogLikelihood(
const arma::mat& data,
const std::vector<arma::vec>& meansL,
const std::vector<arma::mat>& covariancesL,
const arma::vec& weightsL) const
{
double loglikelihood = 0;
arma::vec phis;
arma::mat likelihoods(gaussians, data.n_cols);
for (size_t i = 0; i < gaussians; i++)
{
phi(data, meansL[i], covariancesL[i], phis);
likelihoods.row(i) = weightsL(i) * trans(phis);
}
// Now sum over every point.
for (size_t j = 0; j < data.n_cols; j++)
loglikelihood += log(accu(likelihoods.col(j)));
return loglikelihood;
}
int main()
{
int i,n;
double p,min=2147483647.0,ph,epsilon=0.000000001;
for(i=2;i<MAX;i++)
{
if(i%100000==0)
printf("%d\n",i);
ph=(double)phi(i);
if(isPermutation(i,ph))
{
p=n/ph;
if(min-p > epsilon)
{
min=p;
n=i;
}
}
}
printf("answer = %d\n",n);
return 0;
}
void SpalartAllmaras::correct(const tmp<volTensorField>& gradU)
{
LESModel::correct(gradU);
if (mesh_.changing())
{
y_.correct();
y_.boundaryField() = max(y_.boundaryField(), VSMALL);
}
const volScalarField S(this->S(gradU));
const volScalarField dTilda(this->dTilda(S));
const volScalarField STilda(this->STilda(S, dTilda));
tmp<fvScalarMatrix> nuTildaEqn
(
fvm::ddt(nuTilda_)
+ fvm::div(phi(), nuTilda_)
- fvm::laplacian
(
(nuTilda_ + nu())/sigmaNut_,
nuTilda_,
"laplacian(DnuTildaEff,nuTilda)"
)
- Cb2_/sigmaNut_*magSqr(fvc::grad(nuTilda_))
==
Cb1_*STilda*nuTilda_
- fvm::Sp(Cw1_*fw(STilda, dTilda)*nuTilda_/sqr(dTilda), nuTilda_)
);
nuTildaEqn().relax();
nuTildaEqn().solve();
bound(nuTilda_, dimensionedScalar("zero", nuTilda_.dimensions(), 0.0));
nuTilda_.correctBoundaryConditions();
updateSubGridScaleFields();
}
