Ejemplo n.º 1
0
        Matrix<N, M, Container> Matrix<M, N, Container>::invert() const
        {
            Matrix<N, M, Container> result;

            gsl_matrix* Z1 = gsl_matrix_alloc(M, M);
            gsl_matrix* Z = gsl_matrix_alloc(M, M);
            gsl_permutation* perm = gsl_permutation_alloc(M);
            int k;

            for (uint i = 0; i < M; i++)
                for (uint j = 0; j < M; j++)
                    gsl_matrix_set(Z1, i, j, (*this)(i, j));

            if (gsl_linalg_LU_decomp(Z1, perm, &k))
                THROW_INVALID_ARG("gsl_linalg_LU_decomp failed");
            
            if (gsl_linalg_LU_invert(Z1, perm, Z))
                THROW_INVALID_ARG("gsl_linalg_LU_invert failed");
            
            for (uint i = 0; i < M; i++)
                for (uint j = 0; j < M; j++)
                    result(i, j) = gsl_matrix_get(Z, i, j);

            gsl_permutation_free(perm);
            gsl_matrix_free(Z);
            gsl_matrix_free(Z1);

            return result;
        }
Ejemplo n.º 2
0
std::string xml::Node::getAttributeByName(const std::string& name) const
{
    auto attrs = getAttributes();
    auto iter = attrs.find(name);
    if (iter != attrs.end())
        return iter->second;
    THROW_INVALID_ARG("Attribute \"" + name + "\" not found in list and default value is not provided");
}
Ejemplo n.º 3
0
xml::Node xml::Node::getChildByName(const std::string& name) const
{
    NodeList nodes = getChildrenByName(name);
    auto l = nodes.size();
    if (l != 1) {
        LOG_ERROR("Expected one node with name " << name << " but found " << l);
        THROW_INVALID_ARG("Child not found");
    }
    return nodes[0];
}
	/**
	 * Given with 6 point-value pairs, determine among them tetrahedron that
	 * contains the query point inside and perform linear interpolation in it
	 * @param c_i and v_i - points and values
	 * @param q point to interpolate
	 */
	static TValue interpolateInOwner(const Real3& c0, const TValue v0,
	                                 const Real3& c1, const TValue v1,
	                                 const Real3& c2, const TValue v2,
	                                 const Real3& c3, const TValue v3,
	                                 const Real3& c4, const TValue v4,
	                                 const Real3& c5, const TValue v5,
	                                 const Real3& q) {
		Real4 lambda;
		
		#define TRY_TETRAHEDRON(a, b, d, e) \
		if (linal::volume(c##a, c##b, c##d, c##e) != 0) { \
			lambda = linal::barycentricCoordinates(c##a, c##b, c##d, c##e, q); \
			if (isInterpolation(lambda)) { \
				return lambda(0) * v##a + lambda(1) * v##b + \
				       lambda(2) * v##d + lambda(3) * v##e; \
			} \
		}
		
		TRY_TETRAHEDRON(0, 1, 2, 3)
		TRY_TETRAHEDRON(0, 1, 2, 4)
		TRY_TETRAHEDRON(0, 1, 2, 5)
		TRY_TETRAHEDRON(0, 1, 3, 4)
		TRY_TETRAHEDRON(0, 1, 3, 5)
		TRY_TETRAHEDRON(0, 1, 4, 5)
		
		TRY_TETRAHEDRON(0, 2, 3, 4)
		TRY_TETRAHEDRON(0, 2, 3, 5)
		TRY_TETRAHEDRON(0, 2, 4, 5)
		
		TRY_TETRAHEDRON(0, 3, 4, 5)
		
		TRY_TETRAHEDRON(1, 2, 3, 4)
		TRY_TETRAHEDRON(1, 2, 3, 5)
		TRY_TETRAHEDRON(1, 2, 4, 5)
		
		TRY_TETRAHEDRON(1, 3, 4, 5)
		
		TRY_TETRAHEDRON(2, 3, 4, 5)
		
		#undef TRY_TETRAHEDRON
		
		THROW_INVALID_ARG("Containing tetrahedron is not found");
}
void gcm::AnisotropicMatrix3DAnalytical::findEigenVec (double *eigenVec1,
		double *eigenVec2, double l, float rho, const IAnisotropicElasticMaterial::RheologyParameters &C, int stage)
{
    // Analitycal search eigenvectors
    // M * x = 0, x = (x1, x2, x3)
    // then x[4-9] <= x[1-3]
    double** M = new double* [3];
    for (int i = 0; i < 3; i++)
        M[i] = new double [3];

    switch ( stage ) {
        case 0 :
        {
            M[0][0] = -C.c11 + rho*l*l;
            M[1][2] = -C.c55 + rho*l*l;
            M[2][1] = -C.c66 + rho*l*l;
            M[0][1] = M[2][0] = -C.c16;
            M[0][2] = M[1][0] = -C.c15;
            M[1][1] = M[2][2] = -C.c56;
            break;
        }
        case 1 :
        {
            M[0][1] = -C.c22 + rho*l*l;
            M[1][2] = -C.c44 + rho*l*l;
            M[2][0] = -C.c66 + rho*l*l;
            M[0][0] = M[2][1] = -C.c26;
            M[1][0] = M[2][2] = -C.c46;
            M[1][1] = M[0][2] = -C.c24;
            break;
        }
        case 2 :
        {
            M[0][2] = -C.c33 + rho*l*l;
            M[1][1] = -C.c44 + rho*l*l;
            M[2][0] = -C.c55 + rho*l*l;
            M[0][0] = M[2][2] = -C.c35;
            M[2][1] = M[1][0] = -C.c45;
            M[0][1] = M[1][2] = -C.c34;
            break;
        }
        default:
            THROW_INVALID_ARG("Wrong stage number (from findEigenVec)");
    }

    findNonZeroSolution(M, eigenVec1, eigenVec2);

    switch ( stage ) {
        case 0 :
        {
            eigenVec1[3] = -rho*l*eigenVec1[0];
            eigenVec1[8] = -rho*l*eigenVec1[1];
            eigenVec1[7] = -rho*l*eigenVec1[2];
            eigenVec1[4] = -(C.c12*eigenVec1[0] + C.c26*eigenVec1[1] + C.c25*eigenVec1[2])/l;
            eigenVec1[5] = -(C.c13*eigenVec1[0] + C.c36*eigenVec1[1] + C.c35*eigenVec1[2])/l;
            eigenVec1[6] = -(C.c14*eigenVec1[0] + C.c46*eigenVec1[1] + C.c45*eigenVec1[2])/l;
            eigenVec2[3] = -rho*l*eigenVec2[0];
            eigenVec2[8] = -rho*l*eigenVec2[1];
            eigenVec2[7] = -rho*l*eigenVec2[2];
            eigenVec2[4] = -(C.c12*eigenVec2[0] + C.c26*eigenVec2[1] + C.c25*eigenVec2[2])/l;
            eigenVec2[5] = -(C.c13*eigenVec2[0] + C.c36*eigenVec2[1] + C.c35*eigenVec2[2])/l;
            eigenVec2[6] = -(C.c14*eigenVec2[0] + C.c46*eigenVec2[1] + C.c45*eigenVec2[2])/l;
            break;
        }
        case 1 :
        {
            eigenVec1[4] = -rho*l*eigenVec1[1];
            eigenVec1[8] = -rho*l*eigenVec1[0];
            eigenVec1[6] = -rho*l*eigenVec1[2];
            eigenVec1[3] = -(C.c16*eigenVec1[0] + C.c12*eigenVec1[1] + C.c14*eigenVec1[2])/l;
            eigenVec1[5] = -(C.c36*eigenVec1[0] + C.c23*eigenVec1[1] + C.c34*eigenVec1[2])/l;
            eigenVec1[7] = -(C.c56*eigenVec1[0] + C.c25*eigenVec1[1] + C.c45*eigenVec1[2])/l;
            eigenVec2[4] = -rho*l*eigenVec2[1];
            eigenVec2[8] = -rho*l*eigenVec2[0];
            eigenVec2[6] = -rho*l*eigenVec2[2];
            eigenVec2[3] = -(C.c16*eigenVec2[0] + C.c12*eigenVec2[1] + C.c14*eigenVec2[2])/l;
            eigenVec2[5] = -(C.c36*eigenVec2[0] + C.c23*eigenVec2[1] + C.c34*eigenVec2[2])/l;
            eigenVec2[7] = -(C.c56*eigenVec2[0] + C.c25*eigenVec2[1] + C.c45*eigenVec2[2])/l;
            break;
        }
        case 2 :
        {
            eigenVec1[7] = -rho*l*eigenVec1[0];
            eigenVec1[6] = -rho*l*eigenVec1[1];
            eigenVec1[5] = -rho*l*eigenVec1[2];
            eigenVec1[3] = -(C.c15*eigenVec1[0] + C.c14*eigenVec1[1] + C.c13*eigenVec1[2])/l;
            eigenVec1[4] = -(C.c25*eigenVec1[0] + C.c24*eigenVec1[1] + C.c23*eigenVec1[2])/l;
            eigenVec1[8] = -(C.c56*eigenVec1[0] + C.c46*eigenVec1[1] + C.c36*eigenVec1[2])/l;
            eigenVec2[7] = -rho*l*eigenVec2[0];
            eigenVec2[6] = -rho*l*eigenVec2[1];
            eigenVec2[5] = -rho*l*eigenVec2[2];
            eigenVec2[3] = -(C.c15*eigenVec2[0] + C.c14*eigenVec2[1] + C.c13*eigenVec2[2])/l;
            eigenVec2[4] = -(C.c25*eigenVec2[0] + C.c24*eigenVec2[1] + C.c23*eigenVec2[2])/l;
            eigenVec2[8] = -(C.c56*eigenVec2[0] + C.c46*eigenVec2[1] + C.c36*eigenVec2[2])/l;
            break;
        }
    }
};