int
AC3D8HexWithSensitivity::update()
{
int i;
double r = 0.0;
double s = 0.0;
Vector epsilon(3);
Matrix sstrain(3,1);
Matrix trial_disp = this->getTotalDisp();
//opserr<<"trial_disp"<<trial_disp<<endln;
this->computeDiff();
for(i = 0; i < numGP; i++) {
const Matrix &dhGlobal = *L[i];
sstrain.addMatrixProduct(0.0, dhGlobal, trial_disp, 1.0);
epsilon(0) = sstrain(0,0);
epsilon(1) = sstrain(1,0);
epsilon(2) = sstrain(2,0);
theMaterial[i]->setTrialStrain(epsilon);
// printf("Integration point: %d\n", i+1);
// printf("epsilon is <%g,%g,%g>\n", epsilon(0), epsilon(1), epsilon(2));
}
return 0;
}
/**
* @function fillEq_PLP
* @brief Fill PLP equations ( 3 Eq - 2 DOF )
*/
void trifocalTensor::fillEq_PLP( cv::Point3f _A,
cv::Point3f _B,
cv::Point3f _C ) {
Eigen::Vector3f A; A << _A.x, _A.y, _A.z;
Eigen::Vector3f B; B << _B.x, _B.y, _B.z;
Eigen::Vector3f C; C << _C.x, _C.y, _C.z;
std::cout << "Correspondence PLP: " << A.transpose() <<"," <<B.transpose() <<"," <<C.transpose() << std::endl;
// 3 equations
for( int s = 0; s < 3; ++s ) {
// T0, T1, T2
for( int i = 0; i < 3; ++i ) {
for( int j = 0; j < 3; ++j ) {
for( int q = 0; q < 3; ++q ) {
for( int k = 0; k < 3; ++k ) {
if( epsilon(k,q,s) != 0 ) {
mEq( mPointer, 9*i + 3*j + q) = A(i)*B(j)*C(k)*epsilon(k,q,s);
}
} // k
} // q
} // j
} // i
mPointer++;
} // s
}
/**
* @function fillEq_PPP
* @brief Fill PPP equations (9 Eq - 4 DOF)
*/
void trifocalTensor::fillEq_PPP( cv::Point3f _A,
cv::Point3f _B,
cv::Point3f _C ) {
Eigen::Vector3f A; A << _A.x, _A.y, _A.z;
Eigen::Vector3f B; B << _B.x, _B.y, _B.z;
Eigen::Vector3f C; C << _C.x, _C.y, _C.z;
printf("[PPP] Correspondence ( %f %f %f ), (%f %f %f) (%f %f %f) \n", A(0), A(1), A(2), B(0), B(1), B(2), C(0), C(1), C(2));
// 3x3 equations
for( int r = 0; r < 3; r++ ) {
for( int s = 0; s < 3; s++ ) {
printf("[PPP] rs: (%d %d) Pointer: %d \n", r, s, mPointer);
Eigen::MatrixXf T0 = Eigen::MatrixXf::Zero(3,3);
Eigen::MatrixXf T1 = Eigen::MatrixXf::Zero(3,3);
Eigen::MatrixXf T2 = Eigen::MatrixXf::Zero(3,3);
std::vector<Eigen::MatrixXf> tempT;
tempT.push_back(T0);
tempT.push_back(T1);
tempT.push_back(T2);
// T0, T1, T2
for( int i = 0; i < 3; i++ ) {
for( int p = 0; p < 3; p++ ) {
for( int q = 0; q < 3; q++ ) {
for( int j = 0; j < 3; j++ ) {
for( int k = 0; k < 3; k++ ) {
if( epsilon(j,p,r) != 0 && epsilon( k, q, s ) != 0 ) {
tempT[i](p,q) += A(i)*B(j)*epsilon(j,p,r)*epsilon(k,q,s)*C(k);
}
/*
float val = A(i)*( (B(j)*epsilon(j,p,r))*(epsilon(k,q,s)*C(k)) );
float temp = tempT[i](p,q) + val;
tempT[i](p,q) = temp; */
} // k
} // j
} // q
} // p
} // i
// Fill matrix
int index = 0;
for( int a = 0; a < 3; ++a ) {
for( int b = 0; b < 3; ++b ) {
for( int c = 0; c < 3; ++c ) {
mEq( mPointer, index) = tempT[a](b,c);
index++;
}
}
}
mPointer++;
} // s
} // r
}
int df(const Eigen::VectorXf &x, Eigen::MatrixXf &fjac) const
{
Eigen::VectorXf epsilon(1);
epsilon(0) = 1e-5;
Eigen::VectorXf fvec1(1);
operator()(x + epsilon, fvec1);
Eigen::VectorXf fvec2(1);
operator()(x - epsilon, fvec2);
fjac = (fvec1 - fvec2)/2.0f;
return 0;
}
/**
* @function fillEq_LLL
* @brief Fill LLL equations ( 3 Equations, 2 DOF )
*/
void trifocalTensor::fillEq_LLL( cv::Point3f _A,
cv::Point3f _B,
cv::Point3f _C ) {
Eigen::Vector3f A; A << _A.x, _A.y, _A.z;
Eigen::Vector3f B; B << _B.x, _B.y, _B.z;
Eigen::Vector3f C; C << _C.x, _C.y, _C.z;
std::cout << "[LLL] Correspondence: " << A.transpose() <<"," <<B.transpose() <<"," <<C.transpose() << std::endl;
// 3 equations
for( int s = 0; s < 3; ++s ) {
// T0, T1, T2
for( int i = 0; i < 3; ++i ) {
for( int j = 0; j < 3; ++j ) {
for( int k = 0; k < 3; ++k ) {
for( int r = 0; r < 3; ++r ) {
mEq( mPointer, 9*i + 3*j + k) += A(r)*B(j)*C(k)*epsilon(r,i,s);
} // r
} // k
} // j
} // i
mPointer++;
} // s
}
// Berechne die kleinste einschliessende Kugel fuer die Punktmenge
Sphere::Sphere(const std::vector<Vector3d>& p,int pointcount) {
//std::vector<Vector3d> v(p);
std::vector<Vector3d> p2;
for(int i=0;i<=pointcount;i++){
p2.push_back(p[i]);
}
std::vector<Vector3d> v(p2);
std::sort(v.begin(),v.end());
v.erase(std::unique(v.begin(),v.end(),epsilonEquals),v.end());
int n = int(v.size());
//random pertutation!
for(int i=n-1;i>0;i--) {
int j = (int) floor(i*double(rand())/RAND_MAX);
Vector3d d = v[i];//+epsilon;
v[i] = v[j];//-epsilon;
v[j] = d;
}
/// alter the points to avoid degenerate cases
Vector3d epsilon(0.00001, -0.00001, 0.0001);
for(int i=0;i<n;i++)
if (rand()<0.5*RAND_MAX) v[i] += epsilon;
else v[i] -= epsilon;
///Hier berechnen wir die Kugel!
//Sphere S = ses0 (n,v);
Sphere S = ses0 (n,v);
center = S.center;
radius = S.radius;
}
//------------------------------------------------------------------------------
void ArcLookAt::autoview(const spire::AABB& bbox, float fov)
{
if (bbox.isNull()) return;
glm::vec3 diag(bbox.getDiagonal());
double w = glm::length(diag);
if (w < 0.000001)
{
spire::AABB bb;
bb.setNull();
glm::vec3 epsilon(0.001, 0.001, 0.001);
bb.extend( bbox.getMin() - epsilon );
bb.extend( bbox.getMax() + epsilon );
w = glm::length(bb.getDiagonal());
}
mCamLookAt = bbox.getCenter();
// We are calculating the distance the camera would need to be away from
// the length of the diagonal of the bbox. See Van Dam, Foley, third edition
// page 304:
// AC = f*tan(O(v)/2)
// => f = AC / tan(O(v)/2)
// Where AC is half the size of the diagonal.
// So, takning into account half the size:
// => f = AC / (2 * tan(O(v) / 2)
mCamDistance = w / (2 * tan(fov / 2.0));
}
const Vector&
ElasticIsotropicPlaneStress2D::getStress (void)
{
double d00 = E/(1.0-v*v);
double d01 = v*d00;
double d22 = 0.5*(d00-d01);
double eps0 = epsilon(0);
double eps1 = epsilon(1);
//sigma = D*epsilon;
sigma(0) = d00*eps0 + d01*eps1;
sigma(1) = d01*eps0 + d00*eps1;
sigma(2) = d22*epsilon(2);
return sigma;
}
void AO_COS::getSample(const int& variable, int& value, Double& weight,myRandom& random)
{
Double epsilon(0.01);
vector<Double> dist(csp->variables[variable]->domain_size());
Double norm_const;
for(int i=0;i<dist.size();i++)
{
if(cp_algo->isConsistent(variable,i))
{
csp->variables[variable]->addr_value()=i;
int entry=Variable::getAddress(sampling_functions[variable].variables());
dist[i]=sampling_functions[variable].table()[entry];
norm_const+=dist[i];
//dist[i]=Double(1.0);
}
}
//cout<<"Var = "<<variable<<": ";
//Double norm_const1;
//for(int i=0;i<dist.size();i++)
//{
// if(dist[i].isZero())
// continue;
// if((dist[i]/norm_const) < epsilon);
// {
// dist[i]=epsilon;
// }
// norm_const1+=dist[i];
// //cout<<dist[i]<<" ";
//}
for(int i=0;i<dist.size();i++)
dist[i]/=norm_const;
/*for(int i=0;i<dist.size();i++)
{
dist[i]/=norm_const1;
}
*/
//cout<<endl;
double sampled_value=random.getDouble();
double cdf=0.0;
for(int i=0;i<dist.size();i++)
{
cdf+=dist[i].value();
if(cdf >= sampled_value)
{
value=i;
weight=dist[i];
return;
}
}
//cerr<<"Should not reach here---Rejection problem\n";
value=0;
weight=Double();
}
void
b_order( game *aGame, player *P, strlist **s )
{
group *g; /* pointer to named group */
group *g2; /* pointer to new group */
int i; /* int value for number of ships */
char *ns; /* char value for number of ships */
DBUG_ENTER( "b_order" );
/* find the named group */
g = findgroup( P, getstr( 0 ) );
if ( !g ) {
mistake( P, INFO, *s, "Group not recognized." );
DBUG_VOID_RETURN;
}
/* check to see if we're detaching from a fleet */
ns = getstr( 0 );
if ( noCaseStrncmp( ns, "fleet", 5 ) == 0 ) {
if ( !epsilon( g->dist, 0.0, 0.0001 ) ) {
mistake( P, WARNING, *s, "Fleet is in hyperspace." );
DBUG_VOID_RETURN;
}
g->thefleet = 0;
DBUG_VOID_RETURN;
}
/* are there enough ships to detach? */
i = atoi( ns );
if ( i > g->ships ) { /* FS Dec 1998 */
mistake( P, INFO, *s, "Not enough ships in group." );
DBUG_VOID_RETURN;
}
/* this was an odd problem */
if ( i < 0 ) { /* KDW July 1999 */
mistake( P, WARNING, *s, "Can't have negative number of ships." );
DBUG_VOID_RETURN;
}
/* create a new group for what's being broken off and add it to
* the list of groups the player owns
*/
g2 = allocStruct( group );
*g2 = *g;
g2->ships = i;
g->ships -= i;
g2->thefleet = 0;
g2->next = NULL;
numberGroup( P, g2 );
g2->name = ( char * ) malloc( 8 );
sprintf( g2->name, "%d", g2->number );
addList( &P->groups, g2 );
DBUG_VOID_RETURN;
}
void Foam::backwardDiffusionFvPatchScalarField::updateCoeffs()
{
if (updated())
{
return;
}
const label patchi = patch().index();
// Calculating alfa
const volVectorField& U = db().lookupObject<volVectorField>("U");
tmp<vectorField> n = patch().nf();
alfa() = -(n & U.boundaryField()[patchi]);
// Calculating eta
const volScalarField& rho = db().lookupObject<volScalarField>("rho");
eta() = rho0() / rho.boundaryField()[patchi];
nameInternal_ = dimensionedInternalField().name();
bool soretEffect = db().foundObject<volScalarField>("gas::Dsoret_" + nameInternal_);
// Calculating epsilon
if (soretEffect == true)
{
const volScalarField& Dsoret = db().lookupObject<volScalarField>("gas::Dsoret_" + nameInternal_);
const volScalarField& T = db().lookupObject<volScalarField>("T");
epsilon() = -T.boundaryField()[patchi].snGrad() / T.boundaryField()[patchi] * Dsoret.boundaryField()[patchi];
}
else
{
epsilon() = 0.;
}
// Calculating beta
nameInternal_ = dimensionedInternalField().name();
const volScalarField& Dmix = db().lookupObject<volScalarField>("gas::Dmix_" + nameInternal_);
beta() = Dmix.boundaryField()[patchi]*this->patch().deltaCoeffs();
if (debug)
{
}
mixedUserDefinedFvPatchScalarField::updateCoeffs();
}
const Vector&
ElasticIsotropicPlaneStrain2D::getStress (void)
{
double mu2 = E/(1.0+v);
double lam = v*mu2/(1.0-2.0*v);
double mu = 0.50*mu2;
double eps0 = epsilon(0);
double eps1 = epsilon(1);
mu2 += lam;
//sigma = D*epsilon;
sigma(0) = mu2*eps0 + lam*eps1;
sigma(1) = lam*eps0 + mu2*eps1;
sigma(2) = mu*epsilon(2);
return sigma;
}
double MultivariateFNormalSufficient::get_mean_square_residuals() const
{
//std::cout << "P " << std::endl << P_ << std::endl;
//std::cout << "epsilon " << std::endl << get_epsilon() << std::endl;
VectorXd Peps(get_Peps());
VectorXd epsilon(get_epsilon());
double dist = epsilon.transpose()*Peps;
LOG( "MVN: get_mean_square_residuals = " << dist << std::endl);
return dist;
}
/*
** The GEI to GSE transformation is given by the matrix
**
** T2 = <lambdaO,Z>*<epsilon,X>
**
** where the rotation angle lambdaO is the Sun's ecliptic longitude and
** the angle epsilon is the obliquity of the ecliptic. This transformation
** is a rotation from the Earth's equator to the plane of the ecliptic
** followed by a rotation in the plane of the ecliptic from the First Point
** of Aries to the Earth-Sun direction.
*/
void
mat_T2(const double et, Mat mat)
{
Mat mat_tmp;
hapgood_matrix(lambda0(et), Z, mat);
hapgood_matrix(epsilon(et), X, mat_tmp);
mat_times_mat(mat, mat_tmp, mat);
}
const XC::Vector &XC::ElasticIsotropicPlateFiber::getStress(void) const
{
const double d00 = E/(1.0-v*v);
const double d01 = v*d00;
const double d22 = 0.5*(d00-d01);
const double eps0 = epsilon(0);
const double eps1 = epsilon(1);
//sigma = D*epsilon;
sigma(0) = d00*eps0 + d01*eps1;
sigma(1) = d01*eps0 + d00*eps1;
sigma(2) = d22*epsilon(2);
sigma(3) = d22*epsilon(3);
sigma(4) = d22*epsilon(4);
return sigma;
}
int main(int argc, char** argv)
{
int matrix_size;
int silent = 0;
int optchar;
elem_t *a, *inv, *prod;
elem_t eps;
double error;
double ratio;
while ((optchar = getopt(argc, argv, "qt:")) != EOF)
{
switch (optchar)
{
case 'q': silent = 1; break;
case 't': s_nthread = atoi(optarg); break;
default:
fprintf(stderr, "Error: unknown option '%c'.\n", optchar);
return 1;
}
}
if (optind + 1 != argc)
{
fprintf(stderr, "Error: wrong number of arguments.\n");
}
matrix_size = atoi(argv[optind]);
/* Error checking. */
assert(matrix_size >= 1);
assert(s_nthread >= 1);
eps = epsilon();
a = new_matrix(matrix_size, matrix_size);
init_matrix(a, matrix_size, matrix_size);
inv = invert_matrix(a, matrix_size);
prod = multiply_matrices(a, matrix_size, matrix_size,
inv, matrix_size, matrix_size);
error = identity_error(prod, matrix_size);
ratio = error / (eps * matrix_size);
if (! silent)
{
printf("error = %g; epsilon = %g; error / (epsilon * n) = %g\n",
error, eps, ratio);
}
if (isfinite(ratio) && ratio < 100)
printf("Error within bounds.\n");
else
printf("Error out of bounds.\n");
delete_matrix(prod);
delete_matrix(inv);
delete_matrix(a);
return 0;
}
const XC::Vector &XC::ElasticIsotropicAxiSymm::getStress(void) const
{
double mu2 = E/(1.0+v);
double lam = v*mu2/(1.0-2.0*v);
double mu = 0.50*mu2;
double eps0 = epsilon(0);
double eps1 = epsilon(1);
double eps2 = epsilon(2);
mu2 += lam;
//sigma = D*epsilon;
sigma(0) = mu2*eps0 + lam*(eps1+eps2);
sigma(1) = mu2*eps1 + lam*(eps0+eps2);
sigma(2) = mu2*eps2 + lam*(eps0+eps1);
sigma(3) = mu*epsilon(3);
return sigma;
}
double three_body_system::calc_sf_channel_summand(int kappa, int nr, int nrho, vector<double> transformed_state, double rP) {
double u = transformed_state[0];
double v = transformed_state[2];
double w = transformed_state[1];
return
epsilon(kappa, w) * sqrt(2.0*kappa + 1.0) * fact2[2*nrho] * pow(abs(w), kappa)
/ pow(v, 1.5 + nrho + kappa) * pow(rP, 2 + 2*nr + 2*kappa) * exp(-0.5 * (u - w*w/v) * rP * rP)
* gsl_sf_laguerre_n(nrho, double(kappa) + 0.5, -rP * rP * w * w / v / 2.0);
}
// greebo: This is called if the window size changes (camera, orthoview)
void RadiantWindowObserver::onSizeChanged(int width, int height)
{
// Store the new width and height
_width = width;
_height = height;
// Rescale the epsilon accordingly...
DeviceVector epsilon(_selectEpsilon / _width, _selectEpsilon / _height);
// ...and pass it to the helper classes
_selectObserver._epsilon = epsilon;
_manipulateObserver._epsilon = epsilon;
}
const Vector&
PressureDependentElastic3D::getStress (void)
{
double p = p_n;
if (p <= p_cutoff)
p = p_cutoff;
double Eo = E * pow(p/p_ref, exp0);
double mu2 = Eo/(1.0+v);
double lam = v*mu2/(1.0-2.0*v);
double mu = 0.50*mu2;
mu2 += lam;
double eps0 = epsilon(0);
double eps1 = epsilon(1);
double eps2 = epsilon(2);
sigma(0) = mu2*eps0 + lam*(eps1+eps2);
sigma(1) = mu2*eps1 + lam*(eps2+eps0);
sigma(2) = mu2*eps2 + lam*(eps0+eps1);
p_n1 = (sigma(0)+sigma(1)+sigma(2))/3.0;
sigma(3) = mu*epsilon(3);
sigma(4) = mu*epsilon(4);
sigma(5) = mu*epsilon(5);
return sigma;
}
void print_limits (std::ostream &strm, const char *tname, T)
{
#define PRINT_MEMBER(type, member) \
strm << " static " << type << " " #member " = " \
<< std::numeric_limits<T>::member << ";\n"
strm << "struct std::numeric_limits<" << tname << "> {\n";
PRINT_MEMBER ("const bool", is_specialized);
PRINT_MEMBER (tname, min ());
PRINT_MEMBER (tname, max ());
PRINT_MEMBER ("const int", digits);
PRINT_MEMBER ("const int", digits10);
PRINT_MEMBER ("const bool", is_signed);
PRINT_MEMBER ("const bool", is_integer);
PRINT_MEMBER ("const bool", is_exact);
PRINT_MEMBER ("const int", radix);
PRINT_MEMBER (tname, epsilon ());
PRINT_MEMBER ("int", round_error ());
PRINT_MEMBER ("const int", min_exponent);
PRINT_MEMBER ("const int", min_exponent10);
PRINT_MEMBER ("const int", max_exponent);
PRINT_MEMBER ("const int", max_exponent10);
PRINT_MEMBER ("const bool", has_infinity);
PRINT_MEMBER ("const bool", has_quiet_NaN);
PRINT_MEMBER ("const bool", has_signaling_NaN);
PRINT_MEMBER ("const std::float_denorm_style", has_denorm);
PRINT_MEMBER ("const bool", has_denorm_loss);
PRINT_MEMBER (tname, infinity ());
PRINT_MEMBER (tname, quiet_NaN ());
PRINT_MEMBER (tname, signaling_NaN ());
PRINT_MEMBER (tname, denorm_min ());
PRINT_MEMBER ("const bool", is_iec559);
PRINT_MEMBER ("const bool", is_bounded);
PRINT_MEMBER ("const bool", is_modulo);
PRINT_MEMBER ("const bool", traps);
PRINT_MEMBER ("const bool", tinyness_before);
PRINT_MEMBER ("const int", round_style);
strm << "};\n";
}
atmBoundaryLayerInletEpsilonFvPatchScalarField::
atmBoundaryLayerInletEpsilonFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchScalarField(p, iF),
atmBoundaryLayer(patch().Cf(), dict)
{
scalarField::operator=(epsilon(patch().Cf()));
}
Point3D RayDirectionalLight::transparency(RayIntersectionInfo& iInfo,RayShape* shape,Point3D cLimit){
Point3D p0 = iInfo.iCoordinate;
Point3D dir = direction.unit().negate();
Point3D epsilon(0.00001, 0.00001, 0.00001);
epsilon = dir*epsilon;
p0 = p0+epsilon;
Ray3D ray(p0, dir);
double dist = shape->intersect(ray, iInfo, -1);
if (dist > 0) {
return color*iInfo.material->transparent;
}
else return Point3D(1,1,1);
}
int RayDirectionalLight::isInShadow(RayIntersectionInfo& iInfo,RayShape* shape,int& isectCount){
Point3D p0 = iInfo.iCoordinate;
Point3D dir = direction.unit().negate();
Point3D epsilon(0.00001, 0.00001, 0.00001);
epsilon = dir*epsilon;
p0 = p0+epsilon;
Ray3D ray(p0, dir);
double dist = shape->intersect(ray, iInfo, -1);
if (dist > 0) {
return 0;
}
else return 1;
}
std::chrono::duration<double> cis(calculation_data &data) {
std::chrono::duration<double> elapsed_seconds(0);
auto start = std::chrono::steady_clock::now();
// build A matrix
int sz = (data.n_paired/2)*(data.n_baseset-data.n_paired/2);
hermitian_matrix epsilon(sz);
hermitian_matrix J(sz);
hermitian_matrix K(sz);
std::function<int(int,int)> idx = [&](int i,int a) {
return (data.n_baseset-data.n_paired/2)*i + (a-data.n_paired/2);
};
// build epsilon, J and K
for(int i=0; i<data.n_paired/2; i++) {
for(int a=data.n_paired/2; a<data.n_baseset; a++) {
int ia = idx(i,a);
for(int j=0; j<data.n_paired/2; j++) {
for(int b=data.n_paired/2; b<data.n_baseset; b++) {
int jb = idx(j,b);
epsilon(ia,jb) = ( i==j&&a==b ? (data.eigenvalues[a]-data.eigenvalues[i]) : 0 );
J(ia,jb) = data.mo_2eint(a,j,i,b);
K(ia,jb) = data.mo_2eint(a,j,b,i);
}
}
}
}
// build A_singlet and A_triplet
data.A_singlet = epsilon + 2*J - K;
data.A_triplet = epsilon - K;
// solve for eigenvalues
eigen_solver(data.A_singlet, data.ci_singlet_wavefunc, data.ci_singlet_excited);
eigen_solver(data.A_triplet, data.ci_triplet_wavefunc, data.ci_triplet_excited);
auto end = std::chrono::steady_clock::now();
elapsed_seconds = std::chrono::duration_cast<std::chrono::duration<double>>(end-start);
return elapsed_seconds;
}
void testfp(void){
int i;
float a, x;
char buf[30];
ftoa(epsilon(), buf, 6);
printf("\nmachine epsilon: %s", buf);
a = 3.0f / 4.0f;
for (i = 3; i > -7; i--){
x = pow(3.0f, i);
doit(a, x);
}
}
void
BiasSolver::run()
{
DEBUG_BLOCK
debug() << "BiasSolver::run in thread:" << QThread::currentThreadId();
// wait until we get the track collection
{
QMutexLocker locker( &m_collectionResultsMutex );
if( !m_trackCollection )
{
debug() << "waiting for collection results";
m_collectionResultsReady.wait( &m_collectionResultsMutex );
}
debug() << "collection has" << m_trackCollection->count()<<"uids";
}
/*
* Two stage solver: Run ga_optimize and feed it's result into sa_optimize.
*
* Rationale: Genetic algorithms take better advantage of the heuristic used
* by generateInitialPlaylist and also have tendency to converge faster
* initially. How ever, they also tend to get stuck in local minima unless
* the population size is quite large, which is why we switch over to
* simulated annealing when that happens.
*/
/*
* NOTE: For now I am disabling the ga phase, until I can do more
* experimentation.
*/
//Meta::TrackList playlist = ga_optimize( GA_ITERATION_LIMIT, true );
debug() << "generating playlist";
SolverList playlist = generateInitialPlaylist();
debug() << "got playlist with"<<playlist.energy();
// actually for now the simple optimize finds a perfect solution in many cases
simpleOptimize( &playlist );
debug() << "after simple optimize playlist with"<<playlist.energy();
if( playlist.energy() > epsilon() && !m_abortRequested ) // the playlist is only slightly wrong
{
annealingOptimize( &playlist, SA_ITERATION_LIMIT, true );
}
debug() << "Found solution with energy"<<playlist.energy();
m_solution = playlist.m_trackList.mid( m_context.count() );
}
int
ElasticIsotropicPlaneStress2D::recvSelf(int commitTag, Channel &theChannel,
FEM_ObjectBroker &theBroker)
{
static Vector data(7);
int res = theChannel.recvVector(this->getDbTag(), commitTag, data);
if (res < 0) {
opserr << "ElasticIsotropicPlaneStress2D::sendSelf -- could not send Vector\n";
return res;
}
this->setTag((int)data(0));
E = data(1);
v = data(2);
rho = data(3);
epsilon(0)=data(4);
epsilon(1)=data(5);
epsilon(2)=data(6);
Cepsilon = epsilon;
return res;
}
/**
* @function getEq_PPP
* @brief Fill PPP equations (9 Eq - 4 DOF)
*/
Eigen::MatrixXd Tensor3D::getEq_PPP( std::vector<Eigen::VectorXd> _ppp ) {
Eigen::VectorXd A(3), B(3), C(3);
A(0) = _ppp[0](0); A(1) = _ppp[0](1); A(2) = _ppp[0](2);
B(0) = _ppp[1](0); B(1) = _ppp[1](1); B(2) = _ppp[1](2);
C(0) = _ppp[2](0); C(1) = _ppp[2](1); C(2) = _ppp[2](2);
int numEq = 9;
Eigen::MatrixXd ppp = Eigen::MatrixXd::Zero(numEq,27);
int R[] = {0,0,0,1,1,1,2,2,2};
int S[] = {0,1,2,0,1,2,0,1,2};
int r; int s;
for( int ind = 0; ind < numEq; ++ind ) {
r = R[ind];
s = S[ind];
for( int i = 0; i < 3; ++i ) {
for( int p = 0; p < 3; ++p ) {
for( int q = 0; q < 3; ++q ) {
for( int j = 0; j < 3; ++j ) {
for( int k = 0; k < 3; ++k ) {
ppp( ind, 9*i + 3*p + q ) += A(i)*B(j)*epsilon(j, p, r)*C(k)*epsilon(k,q,s);
} // k
} // j
} // q
} // p
} // i
} // ind
return ppp;
}
void ApproxPolyDPTest::testAllocate1()
{
m_operator->initialize();
m_operator->activate();
runtime::DataContainer curve(new cvsupport::Matrix("contour_f32.npy"));
runtime::Float64 epsilon(5.0);
m_operator->setInputData(ApproxPolyDP::INPUT_CURVE, curve);
m_operator->setParameter(ApproxPolyDP::PARAMETER_EPSILON, epsilon);
runtime::DataContainer outCurveResult = m_operator->getOutputData(ApproxPolyDP::OUTPUT_OUT_CURVE);
runtime::ReadAccess outCurveAccess(outCurveResult);
cvsupport::Matrix::save("ApproxPolyDPTest_testAllocate1_outCurve.npy", outCurveAccess.get<runtime::Matrix>());
}