int maindo1(){
MTRand53 mt(1234);
BiasingPotential Ut(-5,5,100,1000);
unsigned long n=0;
double x=0;
double E=tempE(x)+ Ut.getBiasingE(x);
for (n=0;n<1000000;n++){
double dx=(mt()-.5)*2.*0.1;
double newx=x+dx;
double newE=tempE(newx)+ Ut.getBiasingE(newx);
if (newE<E){
x=newx;E=newE;
}
else{
double temp=mt();
if (temp<exp(-newE+E)){
x=newx;
E=newE;
}
}
Ut.collect(x);
if (n % 100000==0)
Ut.pickle("testAF.txt");
}
return 0;
}
//======================================================================
const Vector& EightNode_Brick_u_p::getForceU ()
{
static Vector PpU(Num_ElemDof);
int U_dim[] = {Num_Nodes,Num_Dim};
tensor Ut(2,U_dim,0.0);
int bf_dim[] = {Num_Dim};
tensor bftensor(1,bf_dim,0.0);
bftensor.val(1) = bf(0);
bftensor.val(2) = bf(1);
bftensor.val(3) = bf(2);
double r = 0.0;
double rw = 0.0;
double s = 0.0;
double sw = 0.0;
double t = 0.0;
double tw = 0.0;
double weight = 0.0;
double det_of_Jacobian = 0.0;
tensor Jacobian;
tensor h;
double rho_0 = (1.0-nf)*rho_s + nf*rho_f;
int GP_c_r, GP_c_s, GP_c_t;
for( GP_c_r = 0 ; GP_c_r < Num_IntegrationPts; GP_c_r++ ) {
r = pts[GP_c_r];
rw = wts[GP_c_r];
for( GP_c_s = 0 ; GP_c_s < Num_IntegrationPts; GP_c_s++ ) {
s = pts[GP_c_s];
sw = wts[GP_c_s];
for( GP_c_t = 0 ; GP_c_t < Num_IntegrationPts; GP_c_t++ ) {
t = pts[GP_c_t];
tw = wts[GP_c_t];
Jacobian = this->Jacobian_3D(r,s,t);
det_of_Jacobian = Jacobian.determinant();
h = shapeFunction(r,s,t);
weight = rw * sw * tw * det_of_Jacobian;
Ut += h("a")*bftensor("i") *(weight*rho_0);
}
}
}
PpU.Zero();
int i, j;
for (i=0; i<Num_Nodes; i++) {
for (j=0; j<Num_Dim; j++) {
PpU(i*Num_Dof +j) = Ut.cval(i+1, j+1);
}
}
return PpU;
}
/* ///////////////////////////////////////////////////////////////////////////
// Routine: my_B
//
// Purpose: The source term
//
// Author: Stephen Bond, after Michael Holst
/////////////////////////////////////////////////////////////////////////// */
VPRIVATE double my_B(int d, int m, double *x, double t) {
#if 0
return A * ( Uxx0(d,m,x,t) + Uxx1(d,m,x,t) + Uxx2(d,m,x,t) ) - Ut(d,m,x,t);
#else
return 0.0;
#endif
}
void Foam::pressureInletOutletParSlipVelocityFvPatchVectorField::updateCoeffs()
{
if (updated())
{
return;
}
const surfaceScalarField& phi =
db().lookupObject<surfaceScalarField>(phiName_);
const fvsPatchField<scalar>& phip =
patch().patchField<surfaceScalarField, scalar>(phi);
tmp<vectorgpuField> n = patch().nf();
const gpuField<scalar>& magSf = patch().magSf();
// Get the tangential component from the internalField (zero-gradient)
vectorgpuField Ut(patchInternalField());
Ut -= n()*(Ut & n());
if (phi.dimensions() == dimVelocity*dimArea)
{
refValue() = Ut + n*phip/magSf;
}
else if (phi.dimensions() == dimDensity*dimVelocity*dimArea)
{
const fvPatchField<scalar>& rhop =
patch().lookupPatchField<volScalarField, scalar>(rhoName_);
refValue() = Ut + n*phip/(rhop*magSf);
}
else
{
FatalErrorIn
(
"pressureInletOutletParSlipVelocityFvPatchVectorField::"
"updateCoeffs()"
) << "dimensions of phi are not correct" << nl
<< " on patch " << this->patch().name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalError);
}
valueFraction() = 1.0 - pos(phip);
mixedFvPatchVectorField::updateCoeffs();
}
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;
}
Foam::tmp<Foam::volScalarField>
Foam::diameterModels::IATEsources::turbulentBreakUp::R() const
{
tmp<volScalarField> tR
(
new volScalarField
(
IOobject
(
"R",
iate_.phase().U().time().timeName(),
iate_.phase().mesh()
),
iate_.phase().U().mesh(),
dimensionedScalar("R", dimless/dimTime, 0)
)
);
volScalarField R = tR();
scalar Cti = Cti_.value();
scalar WeCr = WeCr_.value();
volScalarField Ut(this->Ut());
volScalarField We(this->We());
const volScalarField& d(iate_.d()());
forAll(R, celli)
{
if (We[celli] > WeCr)
{
R[celli] =
(1.0/3.0)
*Cti/d[celli]
*Ut[celli]
*sqrt(1 - WeCr/We[celli])
*exp(-WeCr/We[celli]);
}
}
return tR;
}
void BeamColumnJoint3d::getGlobalDispls(Vector &dg)
{
// local variables that will be used in this method
int converge = 0;
int linesearch = 0;
int totalCount = 0;
int dtConverge = 0;
int incCount = 0;
int count = 0;
int maxTotalCount = 1000;
int maxCount = 20;
double loadStep = 0.0;
double dLoadStep = 1.0;
double stepSize;
Vector uExtOld(24); uExtOld.Zero();
Vector uExt(12); uExt.Zero();
Vector duExt(12); duExt.Zero();
Vector uIntOld(4); uIntOld.Zero();
Vector uInt(4); uInt.Zero();
Vector duInt(4); duInt.Zero();
Vector duIntTemp(4); duIntTemp.Zero();
Vector intEq(4); intEq.Zero();
Vector intEqLast(4); intEqLast.Zero();
Vector Uepr(24); Uepr.Zero();
Vector UeprInt(4); UeprInt.Zero();
Vector Ut(24); Ut.Zero();
Vector duExtTemp(24); duExtTemp.Zero();
Vector disp1 = nodePtr[0]->getTrialDisp();
Vector disp2 = nodePtr[1]->getTrialDisp();
Vector disp3 = nodePtr[2]->getTrialDisp();
Vector disp4 = nodePtr[3]->getTrialDisp();
for (int i = 0; i < 6; i++)
{
Ut(i) = disp1(i);
Ut(i+6) = disp2(i);
Ut(i+12) = disp3(i);
Ut(i+18) = disp4(i);
}
Uepr = Uecommit;
UeprInt = UeIntcommit;
uExtOld = Uepr;
duExtTemp = Ut - Uepr;
duExt.addMatrixVector(0.0,Transf,duExtTemp,1.0);
uExt.addMatrixVector(0.0,Transf,uExtOld,1.0);
uIntOld = UeprInt;
uInt = uIntOld;
double tol = 1e-12;
double tolIntEq = tol;
double toluInt = (tol>tol*uInt.Norm())? tol:tol*uInt.Norm();
double tolIntEqdU = tol;
double ctolIntEqdU = tol;
double ctolIntEq = tol;
double normDuInt = toluInt;
double normIntEq = tolIntEq;
double normIntEqdU = tolIntEqdU;
Vector u(16); u.Zero();
double engrLast = 0.0;
double engr = 0.0;
Vector fSpring(13); fSpring.Zero();
Vector kSpring(13); kSpring.Zero();
Matrix dintEq_du(4,4); dintEq_du.Zero();
Matrix df_dDef(13,13); df_dDef.Zero();
Matrix tempintEq_du (4,13); tempintEq_du.Zero();
while ((loadStep < 1.0) && (totalCount < maxTotalCount))
{
count = 0;
converge = 0;
dtConverge = 0;
while ((!converge) && (count < maxCount))
{
if (dLoadStep <= 1e-3)
{
dLoadStep = dLoadStep;
}
totalCount ++;
count ++;
for (int ic = 0; ic < 12; ic++ ) {
u(ic) = uExt(ic) + duExt(ic);
}
u(12) = uInt(0);
u(13) = uInt(1);
u(14) = uInt(2);
u(15) = uInt(3);
getMatResponse(u,fSpring,kSpring);
// performs internal equilibrium
intEq(0) = -fSpring(2)-fSpring(3)+fSpring(9)-fSpring(12)/elemHeight;
intEq(1) = fSpring(1)-fSpring(5)-fSpring(7)+fSpring(12)/elemWidth;
intEq(2) = -fSpring(4)-fSpring(8)+fSpring(10)+fSpring(12)/elemHeight;
intEq(3) = fSpring(0)-fSpring(6)-fSpring(11)-fSpring(12)/elemWidth;
matDiag(kSpring, df_dDef);
//////////////////////// dintEq_du = dg_df*df_dDef*dDef_du
tempintEq_du.addMatrixProduct(0.0,dg_df,df_dDef,1.0);
dintEq_du.addMatrixProduct(0.0,tempintEq_du,dDef_du,1.0);
normIntEq = intEq.Norm();
normIntEqdU = 0.0;
for (int jc = 0; jc<4 ; jc++)
{
normIntEqdU += intEq(jc)*duInt(jc);
}
normIntEqdU = fabs(normIntEqdU);
if (totalCount == 1)
{
tolIntEq = (tol>tol*normIntEq) ? tol:tol*normIntEq;
tolIntEqdU = tol;
}
else if (totalCount == 2)
{
tolIntEqdU = (tol>tol*normIntEqdU) ? tol:tol*normIntEqdU;
}
ctolIntEqdU = (tolIntEqdU*dLoadStep > tol) ? tolIntEqdU*dLoadStep:tol;
ctolIntEq = (tolIntEq*dLoadStep > tol) ? tolIntEq*dLoadStep:tol;
// check for convergence starts
if ((normIntEq < tol) || ((normIntEqdU < tol) && (count >1)) || (normDuInt < toluInt) || (dLoadStep < 1e-3))
{
if ((normIntEq > ctolIntEq) || (normIntEqdU > tolIntEqdU) || (normDuInt > toluInt))
{
dtConverge = 1;
}
else
{
dtConverge = 0;
}
converge = 1;
loadStep = loadStep + dLoadStep;
if (fabs(1.0 - loadStep) < tol)
{
loadStep = 1.0;
}
}
else
{
////////////// duInt = -dintEq_du/intEq
dintEq_du.Solve(intEq,duInt);
duInt *= -1;
normDuInt = duInt.Norm();
if (!linesearch)
{
uInt = uInt + duInt;
}
else
{
engrLast = 0.0;
engr = 0.0;
for (int jd = 0; jd<4 ; jd++)
{
engrLast += duInt(jd)*intEqLast(jd);
engr += duInt(jd)*intEq(jd);
}
if (fabs(engr) > tol*engrLast)
{
duIntTemp = duInt;
duIntTemp *= -1;
// lineSearch algorithm requirement
stepSize = getStepSize(engrLast,engr,uExt,duExt,uInt,duIntTemp,tol);
if (fabs(stepSize) > 0.001)
{
uInt = uInt + stepSize*duInt;
}
else
{
uInt = uInt + duInt;
}
}
else
{
uInt = uInt + duInt;
}
intEqLast = intEq;
}
}
}
if (!converge && loadStep < 1.0)
{
incCount = 0;
maxCount = 25;
if (!linesearch)
{
linesearch = 1;
uInt = uIntOld;
duInt.Zero();
}
else
{
opserr << "WARNING : BeamColumnJoint::getGlobalDispls() - convergence problem in state determination" << endln;
uInt = uIntOld;
duInt.Zero();
duExt = duExt*0.1;
dLoadStep = dLoadStep*0.1;
}
}
else if (loadStep < 1.0)
{
maxCount = 10;
incCount ++;
normDuInt = toluInt;
if ((incCount < maxCount) || dtConverge)
{
uExt = uExt + duExt;
if (loadStep + dLoadStep > 1.0)
{
duExt = duExt*(1.0 - loadStep)/dLoadStep;
dLoadStep = 1.0 - loadStep;
incCount = 9;
}
}
else
{
incCount = 0;
uExt = uExt + duExt;
dLoadStep = dLoadStep*10;
if (loadStep + dLoadStep > 1.0)
{
uExt = uExt + duExt*(1.0 - loadStep)/dLoadStep;
dLoadStep = 1.0 - loadStep;
incCount = 9;
}
}
}
}
// determination of stiffness matrix and the residual force vector for the element
formR(fSpring);
formK(kSpring);
for (int ig = 0; ig < 25; ig++ ) {
if (ig<24)
{
dg(ig) = Ut(ig);
}
}
dg(24) = uInt(0);
dg(25) = uInt(1);
dg(26) = uInt(2);
dg(27) = uInt(3);
}
void resultCombiner(const char * name_dv1, const char * name_cm1, const int length1, const char * name_dv2, const char * name_cm2, const int length2, int ftr = 1, const char * outputNameStub = "output")
{
TVectorD dv1(length1), dv2(length2);
TMatrixT<double> cm1(length1, length1), cm2(length2, length2);
double binLimits1[length1][2], binLimits2[length2][2], ccCov1[length1], ccCov2[length1];
readDataVector(name_dv1, dv1, binLimits1, ftr, ccCov1);
printf("Read data vector 1 (%d)\n",length1);
readDataVector(name_dv2, dv2, binLimits2, ftr, ccCov2);
printf("Read data vector 2 (%d)\n",length2);
readCovMatrix(name_cm1, cm1);
printf("Read covariance matrix 1\n");
readCovMatrix(name_cm2, cm2);
printf("Read covariance matrix 2\n");
std::vector<double*> binLimits;
std::vector<std::vector<int > > preU;
int i1 = 0, i2 = 0;
while(i1 < length1 || i2 < length2)
{
if(i1 < length1 && i2 < length2)
{
if((binLimits1[i1][1] + binLimits1[i1][0])/2 > binLimits2[i2][0] && (binLimits1[i1][1] + binLimits1[i1][0])/2 < binLimits2[i2][1])
{
binLimits.push_back(binLimits1[i1]);
std::vector<int> tmp;
tmp.push_back(i1);
tmp.push_back(i2);
preU.push_back(tmp);
i1++;
i2++;
}
else if((binLimits1[i1][1] + binLimits1[i1][0])/2 <= binLimits2[i2][0])
{
binLimits.push_back(binLimits1[i1]);
std::vector<int> tmp;
tmp.push_back(i1);
tmp.push_back(-1);
preU.push_back(tmp);
i1++;
}
else
{
binLimits.push_back(binLimits2[i2]);
std::vector<int> tmp;
tmp.push_back(-1);
tmp.push_back(i2);
preU.push_back(tmp);
i2++;
}
}
else if(i1 < length1 && i2 >= length2)
{
binLimits.push_back(binLimits1[i1]);
std::vector<int> tmp;
tmp.push_back(i1);
tmp.push_back(-1);
preU.push_back(tmp);
i1++;
}
else
{
binLimits.push_back(binLimits2[i2]);
std::vector<int> tmp;
tmp.push_back(-1);
tmp.push_back(i2);
preU.push_back(tmp);
i2++;
}
}
TVectorD dv(length1 + length2);
for(int i = 0; i < length1 + length2; i++)
{
dv[i] = (i < length1) ? dv1[i] : dv2[i - length1];
}
TMatrixT<double> cm(length1 + length2, length1 + length2), U(length1 + length2, preU.size());
for(int i = 0; i < length1; i++)
{
for(int j = 0; j < length1; j++)
{
cm[i][j] = cm1[i][j];
}
}
for(int i = length1; i < length1 + length2; i++)
{
for(int j = length1; j < length1 + length2; j++)
{
cm[i][j] = cm2[i - length1][j - length1];
}
}
for(unsigned int i = 0; i < preU.size(); i++)
{
if(preU[i][0] >= 0) U[preU[i][0]][i] = 1;
if(preU[i][1] >= 0) U[preU[i][1] + length1][i] = 1;
if(ftr > 1 && preU[i][0] >= 0 && preU[i][1] >= 0) cm[preU[i][0]][preU[i][1] + length1] = cm[preU[i][1] + length1][preU[i][0]] = ccCov1[preU[i][0]]*ccCov2[preU[i][1]];
}
// cm.Print();
TMatrixT<double> Ut(U);
Ut.T();
TMatrixT<double> cmInv(cm);
cmInv.Invert();
TMatrixT<double> step1 = Ut * cmInv * U;
TMatrixT<double> step2 = Ut * cmInv;
TMatrixT<double> lambda = step1.Invert() * step2;
TVectorD bV = lambda*dv;
TMatrixT<double> bcm = (Ut * cmInv * U).Invert();
printf("Done with combination.\n");
//write output
FILE *file;
char bVoutName[128], CMoutName[128];
sprintf(bVoutName, "%s_data.txt", outputNameStub);
file = fopen(bVoutName, "w");
if(file)
{
fprintf(file, "#\n#%9s %9s %9s %15s %15s\n", "Bin", "Y_min", "Y_max", "Value", "Uncertainty");
for(int i = 0; i < bV.GetNoElements(); i++)
{
fprintf(file, " %9i %9.2f %9.2f %15e %15e\n", i + 1, binLimits[i][0], binLimits[i][1], bV[i], sqrt(bcm[i][i]));
}
fclose(file);
}
sprintf(CMoutName, "%s_covMat.txt", outputNameStub);
file = fopen(CMoutName, "w");
if(file)
{
fprintf(file, "#\n#%9s %9s %15s\n", "Bin i", "Bin j", "Value");
for(int i = 0; i < bcm.GetNrows(); i++)
{
for(int j = 0; j < bcm.GetNcols(); j++)
{
fprintf(file, " %9i %9i %15e\n", i + 1, j + 1, bcm[i][j]);
}
}
fclose(file);
}
printf("Output complete.\n");
}