//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- TEST(ArrayTest, ReserveAndAdd) { FloatArray a; a.reserve(5); a.add(1.0f); a.add(3.3f); a.add(5.5f); ASSERT_EQ(3u, a.size()); ASSERT_TRUE(a.capacity() >= 5); ASSERT_EQ(1.0f, a[0]); ASSERT_EQ(3.3f, a[1]); ASSERT_EQ(5.5f, a[2]); // To test reuse of buffer float* before = a.ptr(); a.reserve(3); ASSERT_TRUE(a.capacity() >= 5); float* after = a.ptr(); // Check that no realloc has been done ASSERT_EQ(before, after); ASSERT_TRUE(a.capacity() >= 5); }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- TEST(ArrayTest, MinMaxFloat) { FloatArray a; // Test empty arrays EXPECT_FLOAT_EQ(std::numeric_limits<float>::max(), a.min()); EXPECT_FLOAT_EQ(std::numeric_limits<float>::min(), a.max()); a.reserve(5); a.add(1.0f); a.add(-3.3f); a.add(123.5f); a.add(999.9f); a.add(-2.3f); float min = a.min(); float max = a.max(); EXPECT_FLOAT_EQ(-3.3f, min); EXPECT_FLOAT_EQ(999.9f, max); size_t minIdx = 0; size_t maxIdx = 0; a.min(&minIdx); a.max(&maxIdx); EXPECT_EQ(1, minIdx); EXPECT_EQ(3, maxIdx); }
void Tr21Stokes :: computeLoadVector(FloatArray &answer, TimeStep *tStep) { int i, load_number, load_id; Load *load; bcGeomType ltype; FloatArray vec; int nLoads = this->boundaryLoadArray.giveSize() / 2; answer.resize(15); answer.zero(); for ( i = 1; i <= nLoads; i++ ) { // For each Neumann boundary condition load_number = this->boundaryLoadArray.at(2 * i - 1); load_id = this->boundaryLoadArray.at(2 * i); load = this->domain->giveLoad(load_number); ltype = load->giveBCGeoType(); if ( ltype == EdgeLoadBGT ) { this->computeEdgeBCSubVectorAt(vec, load, load_id, tStep); answer.add(vec); } } nLoads = this->giveBodyLoadArray()->giveSize(); for ( i = 1; i <= nLoads; i++ ) { load = domain->giveLoad( bodyLoadArray.at(i) ); ltype = load->giveBCGeoType(); if ( ltype == BodyLoadBGT && load->giveBCValType() == ForceLoadBVT ) { this->computeBodyLoadVectorAt(vec, load, tStep); answer.add(vec); } } }
void CoupledFieldsElement :: giveInternalForcesVectorGen(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord, void (*Nfunc)(GaussPoint*, FloatMatrix), void (*Bfunc)(GaussPoint*, FloatMatrix, int, int), //(GaussPoint*, FloatMatrix) void (*NStressFunc)(GaussPoint*, FloatArray), void (*BStressFunc)(GaussPoint*, FloatArray), double (*dVFunc)(GaussPoint*)) { // General implementation of internal forces that computes // f = sum_gp( N^T*GenStress_N + B^T*GenStress_B ) * dV FloatArray NStress, BStress, vGenStress, NS, BS; FloatMatrix N, B; for ( int j = 0; j < this->giveNumberOfIntegrationRules(); j++ ) { for ( auto &gp: this->giveIntegrationRule(j) ) { double dV = this->computeVolumeAround(gp); // compute generalized stress measures if ( NStressFunc && Nfunc ) { Nfunc(gp, N); NStressFunc(gp, NStress); NS.beTProductOf(N, NStress); answer.add(dV, NS); } if ( BStressFunc && Bfunc ) { Bfunc(gp, B, 1, 3); BStressFunc(gp, BStress); BS.beTProductOf(B, BStress); answer.add(dV, BS); } } } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- TEST(ArrayTest, SetSizeZero) { FloatArray a; a.reserve(3); a.add(1.0f); a.add(3.3f); a.add(5.5f); float* before = a.ptr(); a.setSizeZero(); float* after = a.ptr(); ASSERT_EQ(before, after); ASSERT_EQ(0u, a.size()); ASSERT_TRUE(3 <= a.capacity()); a.add(1.1f); a.add(3.4f); a.add(5.6f); ASSERT_EQ(3u, a.size()); ASSERT_EQ(1.1f, a[0]); ASSERT_EQ(3.4f, a[1]); ASSERT_EQ(5.6f, a[2]); }
void Tr21Stokes :: computeExternalForcesVector(FloatArray &answer, TimeStep *tStep) { FloatArray vec; answer.clear(); int nLoads = this->boundaryLoadArray.giveSize() / 2; for ( int i = 1; i <= nLoads; i++ ) { // For each Neumann boundary condition int load_number = this->boundaryLoadArray.at(2 * i - 1); int load_id = this->boundaryLoadArray.at(2 * i); Load *load = this->domain->giveLoad(load_number); bcGeomType ltype = load->giveBCGeoType(); if ( ltype == EdgeLoadBGT ) { this->computeBoundarySurfaceLoadVector(vec, static_cast< BoundaryLoad * >(load), load_id, ExternalForcesVector, VM_Total, tStep); answer.add(vec); } } BodyLoad *bload; nLoads = this->giveBodyLoadArray()->giveSize(); for ( int i = 1; i <= nLoads; i++ ) { Load *load = domain->giveLoad( bodyLoadArray.at(i) ); if ((bload = dynamic_cast<BodyLoad*>(load))) { bcGeomType ltype = load->giveBCGeoType(); if ( ltype == BodyLoadBGT && load->giveBCValType() == ForceLoadBVT ) { this->computeLoadVector(vec, bload, ExternalForcesVector, VM_Total, tStep); answer.add(vec); } } } }
int TR_SHELL01 :: giveIPValue(FloatArray &answer, GaussPoint *gp, InternalStateType type, TimeStep *atTime) { if ( type == IST_ShellForceMomentumTensor ) { FloatArray aux; GaussPoint *membraneGP = membrane->giveDefaultIntegrationRulePtr()->getIntegrationPoint(gp->giveNumber()-1); GaussPoint *plateGP = plate->giveDefaultIntegrationRulePtr()->getIntegrationPoint(gp->giveNumber()-1); plate->giveIPValue(answer, plateGP, IST_ShellForceMomentumTensor, atTime); membrane->giveIPValue(aux, membraneGP, IST_ShellForceMomentumTensor, atTime); answer.add(aux); return 1; } else if ( type == IST_ShellStrainCurvatureTensor ) { FloatArray aux; GaussPoint *membraneGP = membrane->giveDefaultIntegrationRulePtr()->getIntegrationPoint(gp->giveNumber()-1); GaussPoint *plateGP = plate->giveDefaultIntegrationRulePtr()->getIntegrationPoint(gp->giveNumber()-1); plate->giveIPValue(answer, plateGP, IST_ShellStrainCurvatureTensor, atTime); membrane->giveIPValue(aux, membraneGP, IST_ShellStrainCurvatureTensor, atTime); answer.add(aux); return 1; } else { return StructuralElement::giveIPValue(answer, gp, type, atTime); } }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- TEST(ArrayTest, ExtractElementsFromIndexedArray) { /// source = {2.0, 5.5, 100.0} /// perItemSourceIndices = { 0, 2, 1, 0, 2} /// -> output = {2.0, 100.0, 5.5, 2.0, 100.0} FloatArray source; source.reserve(3); source.add(2.0f); source.add(5.5f); source.add(100.0f); UIntArray indices; indices.reserve(5); indices.add(0); indices.add(2); indices.add(1); indices.add(0); indices.add(2); ref<FloatArray> arr = source.extractElements(indices); ASSERT_EQ(5, arr->size()); EXPECT_FLOAT_EQ( 2.0, arr->get(0)); EXPECT_FLOAT_EQ(100.0, arr->get(1)); EXPECT_FLOAT_EQ( 5.5, arr->get(2)); EXPECT_FLOAT_EQ( 2.0, arr->get(3)); EXPECT_FLOAT_EQ(100.0, arr->get(4)); }
void SUPGElement2 :: computeBCRhsTerm_MB(FloatArray &answer, TimeStep *tStep) { int nLoads; answer.clear(); int rule = 0; IntegrationRule *iRule = this->integrationRulesArray [ rule ]; FloatArray un, gVector, s, helpLoadVector; FloatMatrix b, nu; // add body load (gravity) termms nLoads = this->giveBodyLoadArray()->giveSize(); for ( int i = 1; i <= nLoads; i++ ) { Load *load = domain->giveLoad( bodyLoadArray.at(i) ); bcGeomType ltype = load->giveBCGeoType(); if ( ( ltype == BodyLoadBGT ) && ( load->giveBCValType() == ForceLoadBVT ) ) { load->computeComponentArrayAt(gVector, tStep, VM_Total); if ( gVector.giveSize() ) { for ( GaussPoint *gp: *iRule ) { this->computeUDotGradUMatrix( b, gp, tStep->givePreviousStep() ); this->computeNuMatrix(nu, gp); double dV = this->computeVolumeAround(gp); double rho = this->giveMaterial()->give('d', gp); answer.plusProduct(b, gVector, t_supg * rho * dV); answer.plusProduct(nu, gVector, rho * dV); } } } } // integrate tractions // if no traction bc applied but side marked as with traction load // then zero traction is assumed !!! // loop over boundary load array nLoads = this->giveBoundaryLoadArray()->giveSize() / 2; for ( int i = 1; i <= nLoads; i++ ) { int n = boundaryLoadArray.at(1 + ( i - 1 ) * 2); int id = boundaryLoadArray.at(i * 2); Load *load = domain->giveLoad(n); bcGeomType ltype = load->giveBCGeoType(); if ( ltype == EdgeLoadBGT ) { this->computeEdgeLoadVector_MB(helpLoadVector, load, id, tStep); if ( helpLoadVector.giveSize() ) { answer.add(helpLoadVector); } } else if ( ltype == SurfaceLoadBGT ) { this->computeSurfaceLoadVector_MB(helpLoadVector, load, id, tStep); if ( helpLoadVector.giveSize() ) { answer.add(helpLoadVector); } } else { OOFEM_ERROR("unsupported load type class"); } } }
void SUPGElement2 :: computeBCRhsTerm_MC(FloatArray &answer, TimeStep *tStep) { int nLoads; FloatArray s, gVector, helpLoadVector; FloatMatrix g; int rule = 1; answer.clear(); nLoads = this->giveBodyLoadArray()->giveSize(); for ( int i = 1; i <= nLoads; i++ ) { Load *load = domain->giveLoad( bodyLoadArray.at(i) ); bcGeomType ltype = load->giveBCGeoType(); if ( ( ltype == BodyLoadBGT ) && ( load->giveBCValType() == ForceLoadBVT ) ) { load->computeComponentArrayAt(gVector, tStep, VM_Total); if ( gVector.giveSize() ) { for ( GaussPoint *gp: *this->integrationRulesArray [ rule ] ) { this->computeGradPMatrix(g, gp); double dV = this->computeVolumeAround(gp); answer.plusProduct(g, gVector, t_pspg * dV); } } } } // integrate tractions // if no traction bc applied but side marked as with traction load // then zero traction is assumed !!! // loop over boundary load array nLoads = this->giveBoundaryLoadArray()->giveSize() / 2; for ( int i = 1; i <= nLoads; i++ ) { int n = boundaryLoadArray.at(1 + ( i - 1 ) * 2); int id = boundaryLoadArray.at(i * 2); Load *load = domain->giveLoad(n); bcGeomType ltype = load->giveBCGeoType(); if ( ltype == EdgeLoadBGT ) { this->computeEdgeLoadVector_MC(helpLoadVector, load, id, tStep); if ( helpLoadVector.giveSize() ) { answer.add(helpLoadVector); } } else if ( ltype == SurfaceLoadBGT ) { this->computeSurfaceLoadVector_MC(helpLoadVector, load, id, tStep); if ( helpLoadVector.giveSize() ) { answer.add(helpLoadVector); } } else { OOFEM_ERROR("unsupported load type class"); } } }
void FEI3dTrQuad :: surfaceEvalBaseVectorsAt(FloatArray &G1, FloatArray &G2, const FloatArray &lcoords, const FEICellGeometry &cellgeo) { // Note: These are not normalized. Returns the two tangent vectors to the surface. FloatMatrix dNdxi; this->surfaceEvaldNdxi(dNdxi, lcoords); G1.clear(); G2.clear(); for ( int i = 0; i < 6; ++i ) { G1.add( dNdxi(i, 1), * cellgeo.giveVertexCoordinates(i) ); G2.add( dNdxi(i, 2), * cellgeo.giveVertexCoordinates(i) ); } }
void GradDpElement :: giveLocalInternalForcesVector(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord) { NLStructuralElement *elem = this->giveNLStructuralElement(); int nlGeo = elem->giveGeometryMode(); FloatArray BS, vStress; FloatMatrix B; for ( GaussPoint *gp: *elem->giveIntegrationRule(0) ) { if ( nlGeo == 0 || elem->domain->giveEngngModel()->giveFormulation() == AL ) { elem->computeBmatrixAt(gp, B); } else if ( nlGeo == 1 ) { elem->computeBHmatrixAt(gp, B); } vStress = static_cast< StructuralMaterialStatus * >( gp->giveMaterialStatus() )->giveTempStressVector(); if ( vStress.giveSize() == 0 ) { /// @todo is this check really necessary? break; } // Compute nodal internal forces at nodes as f = B^T*Stress dV double dV = elem->computeVolumeAround(gp); BS.beTProductOf(B, vStress); answer.add(dV, BS); } }
void GradDpElement :: giveNonlocalInternalForcesVector(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord) { double localCumulatedStrain = 0.; NLStructuralElement *elem = this->giveNLStructuralElement(); FloatMatrix stiffKappa; FloatArray Nk; FloatArray aux, dKappa, stress; int size = nSecVars * nSecNodes; //set displacement and nonlocal location array this->setDisplacementLocationArray(); this->setNonlocalLocationArray(); answer.resize(size); for ( GaussPoint *gp: *elem->giveIntegrationRule(0) ) { this->computeNkappaMatrixAt(gp, Nk); double dV = elem->computeVolumeAround(gp); this->computeStressVectorAndLocalCumulatedStrain(stress, localCumulatedStrain, gp, tStep); aux.add(-dV * localCumulatedStrain, Nk); } this->computeStiffnessMatrix_kk(stiffKappa, TangentStiffness, tStep); this->computeNonlocalDegreesOfFreedom(dKappa, tStep); answer.beProductOf(stiffKappa, dKappa); answer.add(aux); }
void PolygonLine :: giveGlobalCoordinates(FloatArray &oGlobalCoord, const double &iArcPos) const { double L = computeLength(); double xSegStart = 0.0, xSegEnd = 0.0; double xiSegStart = 0.0, xiSegEnd = 0.0; size_t numSeg = mVertices.size() - 1; const double xiTol = 1.0e-9; if ( iArcPos < xiTol ) { oGlobalCoord = mVertices [ 0 ]; return; } for ( size_t i = 0; i < numSeg; i++ ) { xSegEnd += mVertices [ i ].distance(mVertices [ i + 1 ]); xiSegStart = xSegStart / L; xiSegEnd = xSegEnd / L; if ( iArcPos > xiSegStart-xiTol && iArcPos < xiSegEnd+xiTol ) { // Point is within the segment FloatArray p; double elXi = ( iArcPos - xiSegStart ) / ( xiSegEnd - xiSegStart ); p.beScaled( ( 1.0 - elXi ), mVertices [ i ] ); p.add(elXi, mVertices [ i + 1 ]); oGlobalCoord = p; return; } } }
void IntermediateConvectionDiffusionAssembler :: vectorFromElement(FloatArray &vec, Element &element, TimeStep *tStep, ValueModeType mode) const { FloatArray vec_p; static_cast< CBSElement & >( element ).computeConvectionTermsI(vec, tStep); static_cast< CBSElement & >( element ).computeDiffusionTermsI(vec_p, tStep); vec.add(vec_p); }
void SimpleVitrificationMaterial :: giveRealStressVector_3d(FloatArray &answer, GaussPoint *gp, const FloatArray &reducedStrain, TimeStep *tStep) { FloatArray strainVector; FloatMatrix d; FloatArray deltaStrain; StructuralMaterialStatus *status = dynamic_cast< StructuralMaterialStatus * >( this->giveStatus(gp) ); this->giveStressDependentPartOfStrainVector(strainVector, gp, reducedStrain, tStep, VM_Total); deltaStrain.beDifferenceOf( strainVector, status->giveStrainVector() ); this->give3dMaterialStiffnessMatrix(d, TangentStiffness, gp, tStep); FloatArray deltaStress; deltaStress.beProductOf(d, deltaStrain); answer = status->giveStressVector(); answer.add(deltaStress); // update gp status->letTempStrainVectorBe(reducedStrain); status->letTempStressVectorBe(answer); }
void DensityRhsAssembler :: vectorFromElement(FloatArray &vec, Element &element, TimeStep *tStep, ValueModeType mode) const { FloatArray vec_p; static_cast< CBSElement & >( element ).computeDensityRhsVelocityTerms(vec, tStep); static_cast< CBSElement & >( element ).computeDensityRhsPressureTerms(vec_p, tStep); vec.add(vec_p); }
void TrabBoneNL3D :: giveRealStressVector_3d(FloatArray &answer, GaussPoint *gp, const FloatArray &totalStrain, TimeStep *tStep) { TrabBoneNL3DStatus *nlStatus = static_cast< TrabBoneNL3DStatus * >( this->giveStatus(gp) ); this->initTempStatus(gp); double tempDam; FloatArray effStress, totalStress, densStress; performPlasticityReturn(gp, totalStrain, tStep); tempDam = computeDamage(gp, tStep); effStress = nlStatus->giveTempEffectiveStress(); totalStress = ( 1 - tempDam ) * effStress; for ( int i = 1; i <= 6; i++ ) { if ( sqrt( totalStress.at(i) * totalStress.at(i) ) < 1e-8 ) { totalStress.at(i) = 0.; } } computePlasStrainEnerDensity(gp, totalStrain, totalStress); if ( densCrit != 0. ) { computeDensificationStress(densStress, gp, totalStrain, tStep); answer.add(densStress); } answer = totalStress; nlStatus->setTempDam(tempDam); nlStatus->letTempStrainVectorBe(totalStrain); nlStatus->letTempStressVectorBe(answer); }
void Tr1Darcy :: computeInternalForcesVector(FloatArray &answer, TimeStep *atTime) { FloatArray *lcoords, w, a, gradP, I; FloatMatrix BT; GaussPoint *gp; TransportMaterial *mat = ( TransportMaterial * ) this->domain->giveMaterial(this->material); IntegrationRule *iRule = integrationRulesArray [ 0 ]; this->computeVectorOf(EID_ConservationEquation, VM_Total, atTime, a); answer.resize(3); answer.zero(); for ( int i = 0; i < iRule->getNumberOfIntegrationPoints(); i++ ) { gp = iRule->getIntegrationPoint(i); lcoords = gp->giveCoordinates(); double detJ = this->interpolation_lin.giveTransformationJacobian( * lcoords, FEIElementGeometryWrapper(this) ); this->interpolation_lin.evaldNdx( BT, * lcoords, FEIElementGeometryWrapper(this) ); gradP.beTProductOf(BT, a); mat->giveFluxVector(w, gp, gradP, atTime); I.beProductOf(BT, w); answer.add(- gp->giveWeight() * detJ, I); } }
int DofManValueField :: evaluateAt(FloatArray &answer, const FloatArray &coords, ValueModeType mode, TimeStep *tStep) { int result = 0; // assume ok FloatArray lc, n; // request element containing target point Element *elem = this->domain->giveSpatialLocalizer()->giveElementContainingPoint(coords); if ( elem ) { // ok element containing target point found FEInterpolation *interp = elem->giveInterpolation(); if ( interp ) { // map target point to element local coordinates if ( interp->global2local( lc, coords, FEIElementGeometryWrapper(elem) ) ) { // evaluate interpolation functions at target point interp->evalN( n, lc, FEIElementGeometryWrapper(elem) ); // loop over element nodes for ( int i = 1; i <= n.giveSize(); i++ ) { // multiply nodal value by value of corresponding shape function and add this to answer answer.add( n.at(i), this->dmanvallist[elem->giveDofManagerNumber(i)-1] ); } } else { // mapping from global to local coordinates failed result = 1; // failed } } else { // element without interpolation result = 1; // failed } } else { // no element containing given point found result = 1; // failed } return result; }
void Tr1Darcy :: computeLoadVector(FloatArray &answer, TimeStep *atTime) { // TODO: Implement support for body forces FloatArray vec; answer.resize(3); answer.zero(); // Compute characteristic vector for Neumann boundary conditions. int i, load_number, load_id; GeneralBoundaryCondition *load; bcGeomType ltype; int nLoads = boundaryLoadArray.giveSize() / 2; for ( i = 1; i <= nLoads; i++ ) { // For each Neumann boundary condition .... load_number = boundaryLoadArray.at(2 * i - 1); load_id = boundaryLoadArray.at(2 * i); load = ( GeneralBoundaryCondition * ) domain->giveLoad(load_number); ltype = load->giveBCGeoType(); if ( ltype == EdgeLoadBGT ) { this->computeEdgeBCSubVectorAt(vec, ( Load * ) load, load_id, atTime); } answer.add(vec); } answer.negated(); }
void GradDpElement :: giveNonlocalInternalForcesVector(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord) { double dV, localCumulatedStrain = 0.; NLStructuralElement *elem = this->giveNLStructuralElement(); FloatMatrix stiffKappa, Nk; FloatArray fKappa(nlSize), aux(nlSize), dKappa, stress; aux.zero(); int size = nSecVars * nSecNodes; //set displacement and nonlocal location array this->setDisplacementLocationArray(locU, nPrimNodes, nPrimVars, nSecNodes, nSecVars); this->setNonlocalLocationArray(locK, nPrimNodes, nPrimVars, nSecNodes, nSecVars); answer.resize(size); for ( GaussPoint *gp: *elem->giveIntegrationRule(0) ) { this->computeNkappaMatrixAt(gp, Nk); for ( int j = 1; j <= nlSize; j++ ) { fKappa.at(j) = Nk.at(1, j); } dV = elem->computeVolumeAround(gp); this->computeStressVectorAndLocalCumulatedStrain(stress, localCumulatedStrain, gp, tStep); fKappa.times(localCumulatedStrain); fKappa.times(-dV); aux.add(fKappa); } this->computeStiffnessMatrix_kk(stiffKappa, TangentStiffness, tStep); this->computeNonlocalDegreesOfFreedom(dKappa, tStep); answer.beProductOf(stiffKappa, dKappa); answer.add(aux); }
void PhaseFieldElement :: giveInternalForcesVector_d(FloatArray &answer, TimeStep *tStep, int useUpdatedGpRecord) { // Computes int_V ( N^t *Nstress_d + B^t * g_c*l*grad(d) ) dV FloatArray NStress, BStress, NS, a_d, grad_d; FloatMatrix N, B; NLStructuralElement *el = this->giveElement(); this->computeDamageUnknowns( a_d, VM_Total, tStep ); for ( auto &gp: el->giveIntegrationRule(0) ) { double dV = el->computeVolumeAround(gp); // compute generalized stress measures this->computeNd_matrixAt( *gp->giveNaturalCoordinates(), N); computeNStress_d(NStress, gp, tStep, useUpdatedGpRecord); NS.beTProductOf(N, NStress); answer.add(dV, NS); this->computeBd_matrixAt(gp, B); grad_d.beProductOf(B, a_d); double l = this->giveInternalLength(); double g_c = this->giveCriticalEnergy(); BStress = grad_d * l * g_c; answer.plusProduct(B, BStress, dV); } }
int IntElPoint :: computeGlobalCoordinates(FloatArray &answer, const FloatArray &lcoords) { answer = *this->giveNode(1)->giveCoordinates(); answer.add(*this->giveNode(2)->giveCoordinates()); answer.times(0.5); return 1; }
void PolygonLine :: giveSubPolygon(std :: vector< FloatArray > &oPoints, const double &iXiStart, const double &iXiEnd) const { double L = computeLength(); double xSegStart = 0.0, xSegEnd = 0.0; double xiSegStart = 0.0, xiSegEnd = 0.0; size_t numSeg = mVertices.size() - 1; const double xiTol = 1.0e-9; if ( iXiStart < xiTol ) { // Add first point oPoints.push_back(mVertices [ 0 ]); } for ( size_t i = 0; i < numSeg; i++ ) { xSegEnd += mVertices [ i ].distance(mVertices [ i + 1 ]); xiSegStart = xSegStart / L; xiSegEnd = xSegEnd / L; if ( iXiStart > xiSegStart-xiTol && iXiStart < xiSegEnd+xiTol ) { // Start point is within the segment FloatArray p; double elXi = ( iXiStart - xiSegStart ) / ( xiSegEnd - xiSegStart ); p.beScaled( ( 1.0 - elXi ), mVertices [ i ] ); p.add(elXi, mVertices [ i + 1 ]); oPoints.push_back(p); } if ( iXiEnd > xiSegStart && iXiEnd < xiSegEnd ) { // End point is within the segment FloatArray p; double elXi = ( iXiEnd - xiSegStart ) / ( xiSegEnd - xiSegStart ); p.beScaled( ( 1.0 - elXi ), mVertices [ i ] ); p.add(elXi, mVertices [ i + 1 ]); oPoints.push_back(p); } if ( xiSegEnd > iXiStart && xiSegEnd < iXiEnd + xiTol ) { // End point of the segment is within range oPoints.push_back(mVertices [ i + 1 ]); } xSegStart = xSegEnd; } }
double LineSurfaceTension :: SpatialLocalizerI_giveDistanceFromParametricCenter(const FloatArray &coords) { FloatArray c; c = *this->giveNode(1)->giveCoordinates(); c.add(*this->giveNode(2)->giveCoordinates()); c.times(0.5); c.subtract(coords); return c.computeNorm(); }
//-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- TEST(ArrayTest, Squeeze) { FloatArray a; a.reserve(5); a.add(1.0f); a.add(3.3f); a.add(5.5f); ASSERT_EQ(3u, a.size()); ASSERT_TRUE(5 <= a.capacity()); a.squeeze(); ASSERT_EQ(3u, a.size()); ASSERT_EQ(3u, a.capacity()); ASSERT_EQ(1.0f, a[0]); ASSERT_EQ(3.3f, a[1]); ASSERT_EQ(5.5f, a[2]); }
void processAudio(AudioBuffer &buffer) { float tune = getParameterValue(PARAMETER_A)*10.0 - 6.0; float fc = getParameterValue(PARAMETER_B)*10.0 - 4.0; float q = getParameterValue(PARAMETER_C)*3+0.75; float shape = getParameterValue(PARAMETER_E)*2; float pw = 0.5; if(shape > 1.0){ pw += 0.49*(shape-1.0); // pw 0.5 to 0.99 shape = 1.0; // square wave } float df = getParameterValue(PARAMETER_D)*4; int di = (int)df; float gain = 0.0f; switch(di){ // a/d case 0: // l/s env.setAttack(1.0-df); env.setRelease(0.0); break; case 1: // s/s env.setAttack(0.0); env.setRelease(df-1); break; case 2: // s/l env.setAttack(df-2); env.setRelease(1.0); break; case 3: // l/l env.setAttack(1.0); env.setRelease(1.0); gain = df-3; break; } env.trigger(isButtonPressed(PUSHBUTTON), getSamplesSinceButtonPressed(PUSHBUTTON)); FloatArray left = buffer.getSamples(LEFT_CHANNEL); FloatArray right = buffer.getSamples(RIGHT_CHANNEL); // vco hz.setTune(tune); float lfreq = hz.getFrequency(left[0]); osc.setFrequency(lfreq); osc.setShape(shape); osc.setPulseWidth(pw); osc.getSamples(left); // vcf hz.setTune(fc); fc = hz.getFrequency(right[0]); fc = min(0.999, max(0.01, fc/(getSampleRate()*2))); // normalised and bounded filter->setLowPass(fc, q); right.copyFrom(left); filter->process(right); right.multiply(0.8-q*0.2); // gain compensation for high q // vca env.getEnvelope(envelope); envelope.add(gain); left.multiply(envelope); right.multiply(envelope); }
void PolygonLine :: computeIntersectionPoints(const FloatArray &iXStart, const FloatArray &iXEnd, std :: vector< FloatArray > &oIntersectionPoints) const { const double detTol = 1.0e-15; int numSeg = this->giveNrVertices() - 1; for(int segIndex = 1; segIndex <= numSeg; segIndex++) { const FloatArray &xStart = this->giveVertex(segIndex); const FloatArray &xEnd = this->giveVertex(segIndex+1); const FloatArray t1 = {xEnd(0) - xStart(0), xEnd(1) - xStart(1)}; const FloatArray t2 = {iXEnd(0) - iXStart(0), iXEnd(1) - iXStart(1)}; double xi1 = 0.0, xi2 = 0.0; int maxIter = 1; for(int iter = 0; iter < maxIter; iter++) { FloatArray temp = {iXStart(0) + xi2*t2(0) - xStart(0) - xi1*t1(0), iXStart(1) + xi2*t2(1) - xStart(1) - xi1*t1(1)}; FloatArray res = {-t1.dotProduct(temp), t2.dotProduct(temp)}; //printf("iter: %d res: %e\n", iter, res.computeNorm() ); FloatMatrix K(2,2); K(0,0) = t1.dotProduct(t1); K(0,1) = -t1.dotProduct(t2); K(1,0) = -t1.dotProduct(t2); K(1,1) = t2.dotProduct(t2); double detK = K.giveDeterminant(); if(detK < detTol) { return; } FloatMatrix KInv; KInv.beInverseOf(K); FloatArray dxi; dxi.beProductOf(KInv, res); xi1 -= dxi(0); xi2 -= dxi(1); } // printf("xi1: %e xi2: %e\n", xi1, xi2); if(xi1 >= 0.0 && xi1 <= 1.0 && xi2 >= 0.0 && xi2 <= 1.0) { FloatArray pos = xStart; pos.add(xi1, t1); oIntersectionPoints.push_back(pos); } } }
void NonLinearDynamic :: computeExternalLoadReactionContribution(FloatArray &reactions, TimeStep *tStep, int di) { if ( ( di == 1 ) && ( tStep == this->giveCurrentStep() ) ) { reactions = incrementalLoadVectorOfPrescribed; reactions.add(initialLoadVectorOfPrescribed); } else { _error("computeExternalLoadReactionContribution: unable to respond due to invalid solution step or domain"); } }