volScalarField dynamicKEqn<BasicTurbulenceModel>::Ck
(
const volSymmTensorField& D,
const volScalarField& KK
) const
{
const volSymmTensorField LL
(
simpleFilter_(dev(filter_(sqr(this->U_)) - (sqr(filter_(this->U_)))))
);
const volSymmTensorField MM
(
simpleFilter_(-2.0*this->delta()*sqrt(KK)*filter_(D))
);
const volScalarField Ck
(
simpleFilter_(0.5*(LL && MM))
/(
simpleFilter_(magSqr(MM))
+ dimensionedScalar("small", sqr(MM.dimensions()), VSMALL)
)
);
tmp<volScalarField> tfld = 0.5*(mag(Ck) + Ck);
return tfld();
}
locDynOneEqEddy::locDynOneEqEddy
(
const volVectorField& U,
const surfaceScalarField& phi,
transportModel& transport
)
:
LESModel(typeName, U, phi, transport),
GenEddyVisc(U, phi, transport),
k_
(
IOobject
(
"k",
runTime_.timeName(),
U_.db(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh_
),
simpleFilter_(U.mesh()),
filterPtr_(LESfilter::New(U.mesh(), coeffDict())),
filter_(filterPtr_())
{
volScalarField KK = 0.5*(filter_(magSqr(U)) - magSqr(filter_(U)));
updateSubGridScaleFields(symm(fvc::grad(U)), KK);
printCoeffs();
}
volScalarField dynOneEqEddy::ck
(
const volSymmTensorField& D,
const volScalarField& KK
) const
{
const volSymmTensorField LL
(
simpleFilter_(dev(filter_(sqr(U())) - (sqr(filter_(U())))))
);
const volSymmTensorField MM
(
simpleFilter_(-2.0*delta()*sqrt(KK)*filter_(D))
);
const volScalarField ck
(
simpleFilter_(0.5*(LL && MM))
/(
simpleFilter_(magSqr(MM))
+ dimensionedScalar("small", sqr(MM.dimensions()), VSMALL)
)
);
tmp<volScalarField> tfld = 0.5*(mag(ck) + ck);
return tfld();
}
void locDynOneEqEddy::correct(const tmp<volTensorField>& gradU)
{
LESModel::correct(gradU);
volSymmTensorField D = symm(gradU);
volScalarField KK = 0.5*(filter_(magSqr(U())) - magSqr(filter_(U())));
KK.max(dimensionedScalar("small", KK.dimensions(), SMALL));
volScalarField P = 2.0*nuSgs_*magSqr(D);
fvScalarMatrix kEqn
(
fvm::ddt(k_)
+ fvm::div(phi(), k_)
- fvm::laplacian(DkEff(), k_)
==
P
- fvm::Sp(ce(D, KK)*sqrt(k_)/delta(), k_)
);
kEqn.relax();
kEqn.solve();
bound(k_, k0());
updateSubGridScaleFields(D, KK);
}
void dynamicKEqn<BasicTurbulenceModel>::correctNut()
{
const volScalarField KK
(
0.5*(filter_(magSqr(this->U_)) - magSqr(filter_(this->U_)))
);
correctNut(symm(fvc::grad(this->U_)), KK);
}
void dynLagrangianCsBound::correct(const tmp<volTensorField>& gradU)
{
LESModel::correct(gradU);
volSymmTensorField S(dev(symm(gradU())));
volScalarField magS(mag(S));
volVectorField Uf(filter_(U()));
volSymmTensorField Sf(dev(symm(fvc::grad(Uf))));
volScalarField magSf(mag(Sf));
volSymmTensorField L(dev(filter_(sqr(U())) - (sqr(filter_(U())))));
volSymmTensorField M(2.0*sqr(delta())*(filter_(magS*S) - 4.0*magSf*Sf));
volScalarField invT
(
(1.0/(theta_.value()*delta()))*pow(flm_*fmm_, 1.0/8.0)
);
volScalarField LM(L && M);
fvScalarMatrix flmEqn
(
fvm::ddt(flm_)
+ fvm::div(phi(), flm_)
==
invT*LM
- fvm::Sp(invT, flm_)
);
flmEqn.relax();
flmEqn.solve();
bound(flm_, flm0_);
volScalarField MM(M && M);
fvScalarMatrix fmmEqn
(
fvm::ddt(fmm_)
+ fvm::div(phi(), fmm_)
==
invT*MM
- fvm::Sp(invT, fmm_)
);
fmmEqn.relax();
fmmEqn.solve();
bound(fmm_, fmm0_);
updateSubGridScaleFields(gradU);
}
volScalarField locDynOneEqEddy::ce
(
const volSymmTensorField& D,
const volScalarField& KK
) const
{
volScalarField ce =
simpleFilter_(nuEff()*(filter_(magSqr(D)) - magSqr(filter_(D))))
/simpleFilter_(pow(KK, 1.5)/(2.0*delta()));
return 0.5*(mag(ce) + ce);
}
volScalarField dynamicKEqn<BasicTurbulenceModel>::Ce() const
{
const volSymmTensorField D(dev(symm(fvc::grad(this->U_))));
volScalarField KK
(
0.5*(filter_(magSqr(this->U_)) - magSqr(filter_(this->U_)))
);
KK.max(dimensionedScalar("small", KK.dimensions(), SMALL));
return Ce(D, KK);
}
volScalarField dynOneEqEddy::ce
(
const volSymmTensorField& D,
const volScalarField& KK
) const
{
const volScalarField ce
(
simpleFilter_(nuEff()*(filter_(magSqr(D)) - magSqr(filter_(D))))
/simpleFilter_(pow(KK, 1.5)/(2.0*delta()))
);
tmp<volScalarField> tfld = 0.5*(mag(ce) + ce);
return tfld();
}
volScalarField dynamicKEqn<BasicTurbulenceModel>::Ce
(
const volSymmTensorField& D,
const volScalarField& KK
) const
{
const volScalarField Ce
(
simpleFilter_(this->nuEff()*(filter_(magSqr(D)) - magSqr(filter_(D))))
/simpleFilter_(pow(KK, 1.5)/(2.0*this->delta()))
);
tmp<volScalarField> tfld = 0.5*(mag(Ce) + Ce);
return tfld();
}
void dynamicKEqn<BasicTurbulenceModel>::correct()
{
if (!this->turbulence_)
{
return;
}
// Local references
const alphaField& alpha = this->alpha_;
const rhoField& rho = this->rho_;
const surfaceScalarField& alphaRhoPhi = this->alphaRhoPhi_;
const volVectorField& U = this->U_;
volScalarField& nut = this->nut_;
fv::options& fvOptions(fv::options::New(this->mesh_));
LESeddyViscosity<BasicTurbulenceModel>::correct();
volScalarField divU(fvc::div(fvc::absolute(this->phi(), U)));
tmp<volTensorField> tgradU(fvc::grad(U));
const volSymmTensorField D(dev(symm(tgradU())));
const volScalarField G(this->GName(), 2.0*nut*(tgradU() && D));
tgradU.clear();
volScalarField KK(0.5*(filter_(magSqr(U)) - magSqr(filter_(U))));
KK.max(dimensionedScalar("small", KK.dimensions(), SMALL));
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(alpha, rho, k_)
+ fvm::div(alphaRhoPhi, k_)
- fvm::laplacian(alpha*rho*DkEff(), k_)
==
alpha*rho*G
- fvm::SuSp((2.0/3.0)*alpha*rho*divU, k_)
- fvm::Sp(Ce(D, KK)*alpha*rho*sqrt(k_)/this->delta(), k_)
+ kSource()
+ fvOptions(alpha, rho, k_)
);
kEqn.ref().relax();
fvOptions.constrain(kEqn.ref());
solve(kEqn);
fvOptions.correct(k_);
bound(k_, this->kMin_);
correctNut(D, KK);
}
volScalarField locDynOneEqEddy::ck
(
const volSymmTensorField& D,
const volScalarField& KK
) const
{
volSymmTensorField LL =
simpleFilter_(dev(filter_(sqr(U())) - (sqr(filter_(U())))));
volSymmTensorField MM = simpleFilter_(-2.0*delta()*pow(KK, 0.5)*filter_(D));
volScalarField ck =
simpleFilter_(0.5*(LL && MM))
/(
simpleFilter_(magSqr(MM))
+ dimensionedScalar("small", sqr(MM.dimensions()), VSMALL)
);
return 0.5*(mag(ck) + ck);
}
dimensionedScalar dynOneEqEddy::ck_(const volSymmTensorField& D) const
{
volScalarField KK = 0.5*(filter_(magSqr(U())) - magSqr(filter_(U())));
volSymmTensorField LL = dev(filter_(sqr(U())) - (sqr(filter_(U()))));
volSymmTensorField MM =
delta()*(filter_(sqrt(k_)*D) - 2*sqrt(KK + filter_(k_))*filter_(D));
return average(LL && MM)/average(magSqr(MM));
}
dynOneEqEddy::dynOneEqEddy
(
const volVectorField& U,
const surfaceScalarField& phi,
transportModel& transport,
const word& turbulenceModelName,
const word& modelName
)
:
LESModel(modelName, U, phi, transport, turbulenceModelName),
GenEddyVisc(U, phi, transport),
k_
(
IOobject
(
"k",
runTime_.timeName(),
mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh_
),
simpleFilter_(U.mesh()),
filterPtr_(LESfilter::New(U.mesh(), coeffDict())),
filter_(filterPtr_())
{
bound(k_, kMin_);
const volScalarField KK(0.5*(filter_(magSqr(U)) - magSqr(filter_(U))));
updateSubGridScaleFields(symm(fvc::grad(U)), KK);
printCoeffs();
}
dimensionedScalar dynOneEqEddy::ce_(const volSymmTensorField& D) const
{
volScalarField KK = 0.5*(filter_(magSqr(U())) - magSqr(filter_(U())));
volScalarField mm =
pow(KK + filter_(k_), 1.5)/(2*delta()) - filter_(pow(k_, 1.5))/delta();
volScalarField ee =
2*delta()*ck_(D)*
(
filter_(sqrt(k_)*magSqr(D))
- 2*sqrt(KK + filter_(k_))*magSqr(filter_(D))
);
return average(ee*mm)/average(mm*mm);
}
/*---------------------------------------------*/
void Filter(csr_t *A, csr_t *B, double drptol) {
/*---------------------------------------------*/
int n,nnz,job,err;
/*---------------------------------------------*/
n = A->n;
nnz = A->nnz;
malloc_csr(n, nnz, B);
job = 2;
filter_(&n, &job, &drptol, A->a, A->ja, A->ia,
B->a, B->ja, B->ia, &nnz, &err);
if (err != 0) {
printf("SPARSKIT filter error![%d]\n", err);
exit(-1);
}
nnz = B->ia[n]-1;
/*------ resize B*/
realloc_csr(B, nnz);
}
void dynamicLagrangian<BasicTurbulenceModel>::correct()
{
if (!this->turbulence_)
{
return;
}
// Local references
const surfaceScalarField& phi = this->phi_;
const volVectorField& U = this->U_;
LESeddyViscosity<BasicTurbulenceModel>::correct();
tmp<volTensorField> tgradU(fvc::grad(U));
const volTensorField& gradU = tgradU();
volSymmTensorField S(dev(symm(gradU)));
volScalarField magS(mag(S));
volVectorField Uf(filter_(U));
volSymmTensorField Sf(dev(symm(fvc::grad(Uf))));
volScalarField magSf(mag(Sf));
volSymmTensorField L(dev(filter_(sqr(U)) - (sqr(filter_(U)))));
volSymmTensorField M
(
2.0*sqr(this->delta())*(filter_(magS*S) - 4.0*magSf*Sf)
);
volScalarField invT
(
(1.0/(theta_.value()*this->delta()))*pow(flm_*fmm_, 1.0/8.0)
);
volScalarField LM(L && M);
fvScalarMatrix flmEqn
(
fvm::ddt(flm_)
+ fvm::div(phi, flm_)
==
invT*LM
- fvm::Sp(invT, flm_)
);
flmEqn.relax();
flmEqn.solve();
bound(flm_, flm0_);
volScalarField MM(M && M);
fvScalarMatrix fmmEqn
(
fvm::ddt(fmm_)
+ fvm::div(phi, fmm_)
==
invT*MM
- fvm::Sp(invT, fmm_)
);
fmmEqn.relax();
fmmEqn.solve();
bound(fmm_, fmm0_);
correctNut(gradU);
}
void intps(float *xi, float *yi, float *xo, float *yo, int nxi, int nxo,
int nt, float dt, int np, float fmin, float fmax, int ntfft,
int niter, float tol,
float *xipre, int nxipre, complex *ccexp, int iccexp,
complex *ccexpo, int iccexpo) {
int it,ix,lftwk;
float df,dxmin;
float *dxi, *dp, *wp;
float *wk, *ftwk;
complex *sig, *b, *d, *r, *wk1, *wk2, *wk3, *wk4, *wk5;
complex *swk, *fyi, *si, *so;
complex ctemp;
int ifmin, nph, nf, inifft, iniwp;
float *xip, *yip, dxp;
int nxip, npp;
int icexp, icexpo;
/* check to see if the input xi is changed or not */
if(iccexp == -1) {
icexp = -1;
} else {
icexp = 0;
icexpo = 0;
if(nxi == nxipre) {
icexp = 1;
icexpo = 1;
for(ix=0;ix<nxi;ix++) {
if(xi[ix]!=xipre[ix]) {
icexp = 0;
icexpo = 0;
break;
}
}
}
}
if(iccexpo == -1) {
icexpo = -1;
}
/* pad input data 5 traces on each side */
nxip = nxi + 10;
npp = np + 10;
dxi = (float*)malloc(nxip*sizeof(float));
xip = (float*)malloc(nxip*sizeof(float));
yip = (float*)malloc(nxip*nt*sizeof(float));
if(nxi>1) {
dxp = xi[1] - xi[0];
} else {
dxp = 1;
}
for(ix=0;ix<5;ix++) {
xip[ix] = xi[0] + (ix-5)*dxp;
/* taper first trace and put at padded trace location */
for(it=0;it<nt;it++) {
yip[it+ix*nt]=yi[it]*(ix+1.)/5.;
}
}
for(ix=0;ix<nxi;ix++) {
xip[ix+5] = xi[ix];
for(it=0;it<nt;it++) yip[it+(ix+5)*nt] = yi[it+ix*nt];
}
if(nxi>1) {
dxp = xi[nxi-1] - xi[nxi-2];
} else {
dxp = 1;
}
for(ix=0;ix<5;ix++) {
xip[nxi+5+ix] = xi[nxi-1] + (ix+1)*dxp;
/* taper last trace and put at padded trace location */
for(it=0;it<nt;it++) {
yip[it+(ix+nxi+5)*nt]=yi[it+(nxi-1)*nt]*(5.-ix)/5.;
}
}
/* initialize tau-p interpolation */
initpf_(&ntfft,&dt,&fmin,&fmax,&nxip,&ifmin,&df,
&nf,&lftwk,&npp,&nph);
/* design inverse filter */
d = (complex*)malloc(npp*sizeof(complex));
sig = (complex*)malloc(npp*sizeof(complex));
r = (complex*)malloc(npp*npp*sizeof(complex));
b = (complex*)malloc(npp*sizeof(complex));
wk1 = (complex*)malloc(npp*sizeof(complex));
wk2 = (complex*)malloc(npp*sizeof(complex));
wk3 = (complex*)malloc(npp*sizeof(complex));
wk4 = (complex*)malloc(npp*sizeof(complex));
wk5 = (complex*)malloc(npp*sizeof(complex));
filter_(xip,&nxip,&nph,dxi,&dxmin,
d,sig,r,b,wk1,wk2,wk3,wk4,wk5,&tol,&niter);
free(sig);
free(r);
free(b);
free(wk1);
free(wk2);
free(wk3);
free(wk4);
free(wk5);
/* trace fft */
fyi = (complex*)malloc(nf*nxip*sizeof(complex));
ftwk = (float*)malloc(lftwk*sizeof(float));
wk = (float*)malloc(ntfft*sizeof(float));
inifft = 0;
trafft_(yip,fyi,wk,ftwk,&nt,&ntfft,&nxip,
&ifmin,&nf,&lftwk,&inifft);
/* forward tau-p in frequency domain */
iniwp = 0;
si = (complex*)malloc(nf*npp*sizeof(complex));
wp = (float*)malloc(nf*npp*sizeof(float));
dp = (float*)malloc(nf*sizeof(float));
fwdtp_(fyi,si,wp,dp,&nf,&ifmin,&df,
&nph,xip,dxi,&nxip,&dxmin,&iniwp,ccexp,&icexp);
free(fyi);
free(dxi);
/* apply the filter */
so = (complex*) malloc(nf*npp*sizeof(complex));
filtp_(si,so,d,&nf,&nph);
free(si);
free(d);
/* inverse tau-p transform */
swk = (complex*)malloc(nf*sizeof(complex));
invtp_(so,yo,dp,swk,wp,xo,wk,ftwk,
&nf,&nt,&ntfft,&nxo,&nph,&ifmin,&lftwk,
ccexpo,&icexpo);
free(so);
free(swk);
free(wp);
free(wk);
free(ftwk);
free(dp);
free(xip);
free(yip);
np = npp;
}
void Fsystem::walkdir(const char * pathname) {
int32_t max_path_size = 1024;
char absolute_path[1024] = {'\0'};
DIR* dirp = opendir(pathname);
struct dirent* p_dirent;
struct dirent dirent;
if (NULL == dirp) {
char* err_msg = NULL;
if (errno == EACCES) {
err_msg = "no permission";
} else if (errno == ENFILE) {
err_msg = "too many files open";
} else if (errno == EMFILE) {
err_msg = "too many fd open";
} else if (errno == ENOMEM) {
err_msg = "too many dirs open";
} else {
err_msg = "Unknown";
}
exit(-1);
}
int ret = chdir(pathname);
if (ret != 0) {
exit(-1);
}
while (0 == readdir_r(dirp, &dirent, &p_dirent)) {
if (NULL == p_dirent) {
break;
}
char * d_name = dirent.d_name;
if (!strcmp(d_name, "..") || !strcmp(d_name, ".")) {
continue;
}
struct stat * st = (struct stat *)malloc(sizeof(struct stat));;
// todo: check malloc
int status = lstat(d_name, st);
if (status == -1){
exit(-1);
}else{
int path_len = snprintf(absolute_path, max_path_size, "%s/%s", pathname, d_name);
absolute_path[path_len] = '\0';
// implantation by function objection
if (filter_ && filter_(absolute_path))
continue;
if(S_ISDIR(st->st_mode)){
this->walkdir(absolute_path);
}else
if (S_ISREG(st->st_mode)) {
travel_cb_.file_handler(absolute_path, st);
}else
if (S_ISLNK(st->st_mode)) {
// check_queue_->insert(absolute_path, st);
travel_cb_.symlink_handler(absolute_path, st);
}else{
}
}
absolute_path[0] = '\0';
}
closedir(dirp);
ret = chdir("../");
if(ret != 0){
exit(-1);
}
}
tmp<volScalarField> scaleSimilarity::k() const
{
return(0.5*(filter_(magSqr(U())) - magSqr(filter_(U()))));
}
tmp<volScalarField> scaleSimilarity::epsilon() const
{
volSymmTensorField D = symm(fvc::grad(U()));
return((filter_(sqr(U())) - sqr(filter_(U()))) && D);
}
tmp<volSymmTensorField> scaleSimilarity::B() const
{
return(filter_(sqr(U())) - sqr(filter_(U())));
}
void logImpl(Backend::FieldInfo const& fi) override
{
if( filter_(fi) )
sink_->log(fi);
}
