void BCI2000OutputFormat::Write( ostream& os, const GenericSignal& inSignal, const StateVector& inStatevector ) { switch( mInputProperties.Type() ) { case SignalType::int16: case SignalType::float32: case SignalType::int32: // Note that the order of Elements and Channels differs from the one in the // socket protocol. for( int j = 0; j < inSignal.Elements(); ++j ) { for( int i = 0; i < inSignal.Channels(); ++i ) inSignal.WriteValueBinary( os, i, j ); os.write( reinterpret_cast<const char*>( inStatevector( min( j, inStatevector.Samples() - 1 ) ).Data() ), inStatevector.Length() ); } break; default: bcierr << "Unsupported signal data type" << endl; } }
/** * Record the ForceReporter quantities. */ int ForceReporter::record(const SimTK::State& s) { if(_model==NULL) return(-1); // MAKE SURE ALL ForceReporter QUANTITIES ARE VALID _model->getMultibodySystem().realize(s, SimTK::Stage::Dynamics ); StateVector nextRow = StateVector(s.getTime()); // Model Forces auto forces = _model->getComponentList<Force>(); for(auto& force : forces) { // If body force we need to record six values for torque+force // If muscle we record one scalar if (force.isDisabled(s)) continue; Array<double> values = force.getRecordValues(s); nextRow.getData().append(values); } if(_includeConstraintForces){ // Model Constraints auto constraints = _model->getComponentList<Constraint>(); for (auto& constraint : constraints) { if (constraint.isDisabled(s)) continue; Array<double> values = constraint.getRecordValues(s); nextRow.getData().append(values); } } _forceStore.append(nextRow); return(0); }
void TessaCreationApi::stopTrackingExtraVariable(int index) { StateVector* endState = currentFunction->getCurrentBasicBlock()->getEndState(); int numberOfVariables = endState->getNumberOfLocals(); int slotIndex = index + numberOfVariables; TessaAssert(index <= numberOfVariables) return endState->deleteLocal(slotIndex); }
// ------------------------------------------------------------------------------------------------- // OperatorList::check(StateVector sv) // // Use: Check the operator list for consitency // Input: StateVector sv - the spin configuration // Output: bool - true if ok, false if not // ------------------------------------------------------------------------------------------------- bool OperatorList::check(StateVector sv) { // Check that no diagonal or off-diagonal operator acts // on two parallel spins int N = sv.getSize(); int L = getSize(); for (int i = 0; i < L; i++) { int op = list->operators[i].op; int spin1 = list->operators[i].spin; int spin2 = spin1 + 1; if (spin2 > (N - 1)) spin2 = 0; if ((op > 0) && (sv(spin1) == sv(spin2))) { cout << "Error: Operating on parallel spins!!" << endl; cout << "operator " << op << " on " << spin1 << "," << spin2; cout << " in " << sv << endl; cout << (*this) << endl; return false; } if (op == 2) { sv.flip(spin1); sv.flip(spin2); } } return true; }
/** * Read sto file. * * @param aFilename name of sto file. */ void MarkerData::readStoFile(const string& aFileName) { if (aFileName.empty()) throw Exception("MarkerData.readStoFile: ERROR- Marker file name is empty",__FILE__,__LINE__); // If the file was written by STOFileAdapter, make the file readable by // Storage. Calls below have no effect otherwise. std::string tmpFileName{"tmp.sto"}; bool versionChanged{revertToVersionNumber1(aFileName, tmpFileName)}; if(versionChanged) addNumRowsNumColumns(tmpFileName, aFileName); std::remove(tmpFileName.c_str()); Storage store(aFileName); // populate map between marker names and column numbers std::map<int, std::string> markerIndices; buildMarkerMap(store, markerIndices); if (markerIndices.size()==0){ throw Exception("MarkerData.readStoFile: ERROR- No markers were identified. Markers should appear on consecutive columns as Marker1.x Marker1.y Marker1.z Marker2.x... etc.",__FILE__,__LINE__); } std::map<int, std::string>::iterator iter; for (iter = markerIndices.begin(); iter != markerIndices.end(); iter++) { SimTK::String markerNameWithSuffix = iter->second; size_t dotIndex = SimTK::String::toLower(markerNameWithSuffix).find_last_of(".x"); SimTK::String candidateMarkerName = markerNameWithSuffix.substr(0, dotIndex-1); _markerNames.append(candidateMarkerName); } // use map to populate data for MarkerData header _numMarkers = (int) markerIndices.size(); _numFrames = store.getSize(); _firstFrameNumber = 1; _dataRate = 250; _cameraRate = 250; _originalDataRate = 250; _originalStartFrame = 1; _originalNumFrames = _numFrames; _fileName = aFileName; _units = Units(Units::Meters); double time; int sz = store.getSize(); for (int i=0; i < sz; i++){ StateVector* nextRow = store.getStateVector(i); time = nextRow->getTime(); int frameNum = i+1; MarkerFrame *frame = new MarkerFrame(_numMarkers, frameNum, time, _units); const Array<double>& rowData = nextRow->getData(); // Cycle through map and add Marker coordinates to the frame. Same order as header. for (iter = markerIndices.begin(); iter != markerIndices.end(); iter++) { int startIndex = iter->first; // startIndex includes time but data doesn't! frame->addMarker(SimTK::Vec3(rowData[startIndex-1], rowData[startIndex], rowData[startIndex+1])); } _frames.append(frame); } }
bool StateVectorLimiter<StateType>::operator()(StateVector<StateType> &_stateVec) const { if((_stateVec.size() != mUpper.size()) |(_stateVec.size() != mLower.size())) { std::cout << "incompatible dimensions. can't evaluate state limits\n"; return false; } }
/** * Copy constructor. */ StateVector::StateVector(const StateVector &aVector) : _data(0.0) { // INITIAL VALUES setNull(); // SET STATES setStates(aVector.getTime(),aVector.getSize(),&aVector.getData()[0]); }
/*** * Returns a shallow copy */ StateVector* StateVector::clone() { StateVector *clone = new (gc) StateVector(currentReferences->size(), gc); for (int32_t i = 0; i < getNumberOfLocals(); i++) { TessaInstruction* currentReference = getLocal(i); clone->setLocal(i, currentReference); } return clone; }
// ------------------------------------------------------------------------------------------------- // OperatorList::diagonalMove(StateVector& sv, double beta) // // Use: Performs a diagonal update on the operator list // Input: StateVector& sv - the spin configuration // double beta - the inverse temperature // Output: none // ------------------------------------------------------------------------------------------------- void OperatorList::diagonalUpdate(StateVector& sv, double beta) { int N = sv.getSize(); // Number of spins int L = getSize(); // Operator list length for (int i = 0; i < L; i++) { int n = countDOD(); // Number of diagonal and off-diagonal operators int op = list->operators[i].op; if (op == 0) { // unit operator // Calculate probability to change operator double P = (double)(N*beta/(2*(L-n))); // Generate a random spin that this operator acts on int spin1 = (int)(ran()*N); // and its adjacent spin int spin2 = (spin1 + 1) % N; // Change operator to diagonal only if the spins are _not_ parallel... if (sv(spin1) != sv(spin2)) { // ...and with probability P double r = ran(); if (r < P) { //cout << "Change..." << endl; list->operators[i].op = 1; list->operators[i].spin = spin1; } } } else if (op == 1) { // diagonal operator // Calculate probability to change to unit operator double P = (double)(2*(L-n+1)/(N*beta)); double r = ran(); // Get the spins this off-diagonal operator acts on int spin1 = list->operators[i].spin; int spin2 = (spin1 + 1) % N; if (r < P) { list->operators[i].op = 0; // unit ops cannot act on spins list->operators[i].spin = -1; } } else if (op == 2) { // off-diagonal operator // Get the spins this off-diagonal operator acts on int spin1 = list->operators[i].spin; int spin2 = (spin1 + 1) % N; // Flip both spins sv.flip(spin1); sv.flip(spin2); } } }
/** Get the angular velocity of the two-body rotating frame. It * is undefined whenever: * - the state of either the primary or secondary object is undefined * - the positions of the primary and secondary object are identical */ Vector3d TwoBodyRotatingFrame::angularVelocity(double t) const { StateVector state = m_secondary->state(t) - m_primary->state(t); if (state.position().isZero()) { return Vector3d::Zero(); } return state.position().cross(state.velocity()) / state.position().squaredNorm(); }
static StateVector getStateAncestors( SLSF::State state ) { StateVector stateVector; stateVector.push_back( state ); Udm::Object object = state.GetParent(); while( object.type() == SLSF::State::meta ) { state = SLSF::State::Cast( object ); stateVector.push_back( state ); object = state.GetParent(); } return stateVector; }
StateVector SourceGaussian::exec( double t){ StateVector State; if(mTE){ // Transverse electric mode double Hz = ScalarGaussian( t, mMean, mSigma); double Ey = c_eta0 * Hz; State.set(0,Ey,0,0,0,Hz); } else { // Transverse magnetic mode double Hy = ScalarGaussian( t, mMean, mSigma); double Ez = c_eta0 * Hy; State.set(0,0,Ez,0,Hy,0); } return State; }
static std::string getFullStateName( SLSF::State state ) { StateVector stateVector = getStateAncestors( state ); std::string fullStateName; bool first = true; while( !stateVector.empty() ) { if ( first ) first = false; else fullStateName += "."; fullStateName += stateVector.back().Name(); stateVector.pop_back(); } return fullStateName; }
// ------------------------------------------------------------------------------------------------- // OperatorList::display(StateVector sv) // // Use: Output a text visualisation of the operator list // Input: StateVector sv - the spin configuration // Output: none // ------------------------------------------------------------------------------------------------- void OperatorList::display(StateVector sv) { int N = sv.getSize(); int L = getSize(); const char* spins[2] = {"U", "D"}; const char* ops[3] = {" ", "-", "="}; for (int i = 0; i < L; i++) { cout << " "; for (int j = 0; j < N; j++) cout << spins[sv(j)] << " "; cout << " (" << i << ")" << endl; int op = list->operators[i].op; if (op == 0) cout << endl; else { int spin1 = list->operators[i].spin; int spin2 = spin1 + 1; if (spin2 > (N - 1)) spin2 = 0; if (spin2 == 0) { cout << " " << ops[op]; for (int k = 0; k < (2*N - 3); k++) cout << " "; cout << ops[op] << endl; } else { for (int k = 0; k < (2*spin1 + 1); k++) cout << " "; for (int k = 0; k < 3; k++) cout << ops[op]; cout << endl; } // flip spins if off diagonal operator if (op == 2) { sv.flip(spin1); sv.flip(spin2); } } } cout << " "; for (int j = 0; j < N; j++) cout << spins[sv(j)] << " "; cout << endl << endl << endl; }
LQRController::UpdateGainsJob::UpdateGainsJob(LQRController * c, const StateMatrix & weights, const InputMatrix &input_weights, const StateVector & target) : c_(c), target_(target) { if(!c) return; ROS_DEBUG_STREAM("target is "<<target.transpose()); const int n=weights.rows(); const int m=input_weights.rows(); input_offset_.resize(m,1); gains_.resize(n,n); //Computes a linearization around the target point StateMatrix A(n,n); InputMatrix B(n,m); if(!c_->model_->getLinearization(target, A, B, input_offset_)) { ROS_ERROR("Failed to get linearization"); c_=NULL; return; } ROS_DEBUG_STREAM("************ Obtained linearization **********\n[A]\n"<<A<<std::endl<<"[B]"<<std::endl<<B<<std::endl<<"[input offset]"<<std::endl<<input_offset_<<"\n*************"); ROS_DEBUG("Sanity checks"); ROS_ASSERT(LQR::isCommandable(A,B)); // Compute new gains matrix ROS_DEBUG("Computing LQR gains matrix. Hold on to your seatbelts..."); LQR::LQRDP<StateMatrix,InputMatrix,StateMatrix,InputMatrix>::runContinuous(A, B, weights, weights, input_weights, 0.01, 0.1, gains_); ROS_DEBUG_STREAM("Done. Computed gains:\n***********\n"<<gains_<<"\n**********\n"); // Check validity ROS_DEBUG("Checking gains matrix..."); bool test=LQR::isConverging(A,B,gains_); ROS_ASSERT(test); ROS_DEBUG("Valid gains matrix"); // assert(test); }
bool LQRController::toStateVector(const std::vector<std::string> & names, const std::vector<double> & positions, const std::vector<double> & velocities, StateVector & v) const { const int N = names.size(); assert(model_); const int n = model_->states(); if(v.rows() != n) { ROS_ERROR("Supplied state vector has wrong size"); return false; } if((int)positions.size()!=N or (int)velocities.size()!=N) { ROS_ERROR("Incoherent data supplied"); return false; } int count=1; for(int i=0;i<N;i++) { const int index=jointIndex(names.at(i)); if(index>=0) { v(index,0)=positions.at(index); v(index+n/2,0)=velocities.at(index); count++; } } if(count!=n) ROS_INFO("The state was only partly specified"); return true; }
void BCI2000OutputFormat::Initialize( const SignalProperties& inProperties, const StateVector& inStatevector ) { mInputProperties = inProperties; mStatevectorLength = inStatevector.Length(); }
/*** * You can get the basic block object by asking the Label to give you the basic block * When you create a basic block, it also creates the parameter instructions for the current number of local variables. * If you are tracking more than just local variables, you have to manually create a parameter instruction later. */ TessaVM::BasicBlock* TessaCreationApi::createNewBasicBlock() { TessaVM::BasicBlock* newBasicBlock = currentFunction->createNewBasicBlock(); this->switchToBasicBlock(newBasicBlock); int localCount = currentFunction->getLocalCount(); StateVector* beginStateVector = new (gc) StateVector(localCount, gc); for (int i = 0; i < localCount; i++) { beginStateVector->setLocal(i, new (gc) ParameterInstruction(NULL, newBasicBlock)); } StateVector* endStateVector = beginStateVector->clone(); newBasicBlock->setBeginState(beginStateVector); newBasicBlock->setEndState(endStateVector); return newBasicBlock; }
void addLoadToStorage(Storage &forceStore, SimTK::Vec3 force, SimTK::Vec3 point, SimTK::Vec3 torque) { int nLoads = forceStore.getColumnLabels().getSize()/9; string labels[9] = { "forceX", "forceY", "forceZ", "pointX", "pointY", "pointZ","torqueX", "torqueY", "torqueZ"}; char suffix[2]; sprintf(suffix, "%d", nLoads); Array<string> col_labels; col_labels.append("time"); StateVector dataRow; dataRow.setTime(0); double data[9]; for(int i = 0; i<9; i++){ col_labels.append(labels[i]); if(i<3){ data[i] = force[i]; continue; } else if(i<6){ data[i] = point[i-3]; continue; } else data[i] = torque[i-6]; } dataRow.setStates(0, 9, data); Storage *forces = NULL; Storage tempStore; if(nLoads == 0) forces = &forceStore; else if (nLoads > 0) forces = &tempStore; else throw OpenSim::Exception("addLoadToStorage: ERROR"); forces->setColumnLabels(col_labels); forces->append(dataRow); dataRow.setTime(1.0); forces->append(dataRow); dataRow.setTime(2.0); forces->append(dataRow); if (nLoads > 0) forces->addToRdStorage(forceStore, 0.0, 1.0); }
/** Get the orientation of the frame at the specified time. The frame's orientation * is undefined whenever one or more of the following is true: * - the state of either the primary or secondary object is undefined * - the positions of the primary and secondary object are identical * - the secondary is stationary with respect to the primary * - the position and velocity vectors are exactly aligned */ Quaterniond TwoBodyRotatingFrame::orientation(double t) const { StateVector state = m_secondary->state(t) - m_primary->state(t); if (state.position().isZero() || state.velocity().isZero()) { return Quaterniond::Identity(); } // Compute the axes of the two body rotating frame, // convert this to a matrix, then derive a quaternion // from this matrix. // x-axis points in direction from the primary to the secondary Vector3d xAxis = state.position().normalized(); Vector3d v = state.velocity().normalized(); Vector3d zAxis; if (m_velocityAlligned) { // z-axis normal to both the x-axis and the velocity vector zAxis = xAxis.cross(v); if (zAxis.isZero()) { return Quaterniond::Identity(); } } else { // z-axis normal to both the x-axis and the z axis of the primary zAxis = xAxis.cross(m_primary->orientation(t) * Vector3d::UnitX()); if (zAxis.isZero()) { return Quaterniond::Identity(); } } zAxis.normalize(); Vector3d yAxis = zAxis.cross(xAxis); Matrix3d m; m << xAxis, yAxis, zAxis; return Quaterniond(m); }
void copyStates( ESMoL::Stateflow inputStateflow, ESMoL::Stateflow outputStateflow ) { getConnectorRefList().clear(); getTransConnectorMap().clear(); StateVector stateVector = inputStateflow.State_kind_children(); for( StateVector::iterator stvItr = stateVector.begin() ; stvItr != stateVector.end() ; ++stvItr ) { ESMoL::State inputState = *stvItr; ESMoL::State outputState = ESMoL::State::Create( outputStateflow ); copyState( inputState, outputState ); } for( ConnectorRefList::iterator crlItr = getConnectorRefList().begin() ; crlItr != getConnectorRefList().end() ; ++crlItr ) { ESMoL::ConnectorRef inputConnectorRef = *crlItr; ESMoL::TransConnector inputTransConnector = inputConnectorRef.ref(); if ( inputTransConnector == Udm::null ) { std::cerr << "Warning: ConnectorRef is a null reference!" << std::endl; continue; } TransConnectorMap::iterator tcmItr = getTransConnectorMap().find( inputConnectorRef ); if ( tcmItr == getTransConnectorMap().end() ) { std::cerr << "Warning: ConnectorRef has no copy in TransConnectorMap" << std::endl; continue; } ESMoL::TransConnector outputTransConnector = tcmItr->second; if ( outputTransConnector.type() != ESMoL::ConnectorRef::meta ) { std::cerr << "Warning: TransConnector should be a ConnectorRef" << std::endl; continue; } ESMoL::ConnectorRef outputConnectorRef = ESMoL::ConnectorRef::Cast( outputTransConnector ); tcmItr = getTransConnectorMap().find( inputTransConnector ); if ( tcmItr == getTransConnectorMap().end() ) { std::cerr << "Warning: TransConnector has no copy in TransConnectorMap" << std::endl; continue; } outputTransConnector = tcmItr->second; outputConnectorRef.ref() = outputTransConnector; } }
void EDFFileWriterBase::PutBlock( const GenericSignal& inSignal, const StateVector& inStatevector ) { for( int i = 0; i < inSignal.Channels(); ++i ) for( int j = 0; j < inSignal.Elements(); ++j ) GDF::Num<T>( inSignal( i, j ) ).WriteToStream( OutputStream() ); for( size_t i = 0; i < mStateNames.size(); ++i ) GDF::PutField< GDF::Num<GDF::int16> >( OutputStream(), inStatevector.StateValue( mStateNames[ i ] ) ); }
bool StateVectorLimiter<StateType>::testState(const StateVector<StateType> &_stateVec) const { bool result = true; if((_stateVec.size() != mUpper.size()) |(_stateVec.size() != mLower.size())) { std::cout << "incompatible dimensions. can't evaluate state limits\n"; return false; } for(unsigned i=0; i < _stateVec.size(); i++) { bool valid = ((mLower(i) <= _stateVec[i]) & (mUpper(i) >= _stateVec[i])); result &= valid; std::string msg = valid ? "ok" : "error"; std::cout << i << ". value=" << _stateVec[i] << "[" << mLower(i) << " ; " << mUpper(i) << msg << "\n"; } return result; }
StateVector BoundaryModuleDrivenBase::getBoundary( const StateVector& Reference, const char dim, const double t){ // TODO Make the boundary both transmissive and driven. // As it stands, it is possible to generate instabilities when backscattered waves meet the boundary. (void)Reference; double driventerm = getDrivenTerm(t); StateVector Boundary; // Set to zero Boundary = ZEROSTATE; // Calculate driven part double electric, magnetic; magnetic = driventerm; electric = c_eta0 * magnetic; // Add to boundary switch(dim){ case 'x': switch(mPOL){ case TE: Boundary.Ey() += electric; Boundary.Hz() += magnetic; break; case TM: Boundary.Ez() += electric; Boundary.Hy() += magnetic; break; } break; case 'y': switch(mPOL){ case TE: Boundary.Ex() += electric; Boundary.Hz() += magnetic; break; case TM: Boundary.Ez() += electric; Boundary.Hx() += magnetic; break; } break; } return Boundary; }
void testPendulum() { ForwardTool forward("pendulum_Setup_Forward.xml"); forward.run(); Storage storage("Results/pendulum_states.sto"); ASSERT(storage.getFirstTime() == 0.0); ASSERT(storage.getLastTime() == 1.0); // Since the pendulum is only swinging through small angles, it should be very // close to a simple harmonic oscillator. double previousTime = -1.0; double amp = SimTK::Pi/20; double k = sqrt(9.80665000/0.5); for (int j = 0; j < storage.getSize(); ++j) { StateVector* state = storage.getStateVector(j); double time = state->getTime(); ASSERT(time > previousTime); previousTime = time; ASSERT_EQUAL(-amp*cos(k*time), state->getData()[0], 1.0e-2); ASSERT_EQUAL(amp*k*sin(k*time), state->getData()[1],1.0e-2); } ASSERT(previousTime == 1.0); }
int main() { cout << endl; cout << "-----------------------------" << endl; cout << "- Propagation Example -" << endl; cout << "-----------------------------" << endl; cout << endl; auto propagator = otl::keplerian::LagrangianPropagator(); // Setup inputs StateVector stateVector; stateVector.position = Vector3d(1131.340, -2282.343, 6672.423); // Absolute position (km) stateVector.velocity = Vector3d(-5.64305, 4.30333, 2.42879); // Absolute velocity (km/s) double mu = ASTRO_MU_EARTH; // Gravitational parameter of Earth Time timeDelta = Time::Minutes(40.0); // Propagate forward 40 minutes cout << "-----------------------------" << endl; cout << "- Input -" << endl; cout << "-----------------------------" << endl; cout << "Initial state vector:" << endl << stateVector.ToDetailedString(" ") << endl; cout << "Propagation time:" << endl << timeDelta.ToDetailedString(" ") << endl; auto initialStateVector = stateVector; // Propagate the state vector forwards in time auto finalStateVector = propagator.PropagateStateVector(initialStateVector, mu, timeDelta); // Now propagate backwards in time to verify we end up where we started auto initialStateVector2 = propagator.PropagateStateVector(finalStateVector, mu, -timeDelta); cout << "-----------------------------" << endl; cout << "- Output -" << endl; cout << "-----------------------------" << endl; cout << "Final state vector:" << endl << finalStateVector.ToDetailedString(" ") << endl; cout << "Initial state vector after backwards propgation:" << endl << initialStateVector2.ToDetailedString(" ") << endl; return 0; }
void testGait2354WithController() { ForwardTool forward("subject01_Setup_Forward_Controller.xml"); forward.run(); Storage results("ResultsCorrectionController/subject01_states.sto"); Storage* standard = new Storage(); string statesFileName("std_subject01_walk1_states.sto"); forward.loadStatesStorage( statesFileName, standard ); Array<double> data; int i = results.getSize() - 1; StateVector* state = results.getStateVector(i); double time = state->getTime(); data.setSize(state->getSize()); standard->getDataAtTime(time, state->getSize(), data); int nc = forward.getModel().getNumCoordinates(); for (int j = 0; j < nc; ++j) { stringstream message; message << "t=" << time <<" state# "<< j << " " << standard->getColumnLabels()[j+1] << " std=" << data[j] <<" computed=" << state->getData()[j]; ASSERT_EQUAL(data[j], state->getData()[j], 1e-2, __FILE__, __LINE__, "ASSERT_EQUAL FAILED " + message.str()); cout << "ASSERT_EQUAL PASSED " << message.str() << endl; } }
/** * Record the ForceReporter quantities. */ int ForceReporter::record(const SimTK::State& s) { if(_model==NULL) return(-1); // MAKE SURE ALL ForceReporter QUANTITIES ARE VALID _model->getMultibodySystem().realize(s, SimTK::Stage::Dynamics ); StateVector nextRow = StateVector(s.getTime()); // NUMBER OF Forces const ForceSet& forces = _model->getForceSet(); // This does not contain gravity int nf = forces.getSize(); for(int i=0;i<nf;i++) { // If body force we need to record six values for torque+force // If muscle we record one scalar OpenSim::Force& nextForce = (OpenSim::Force&)forces[i]; if (nextForce.isDisabled(s)) continue; Array<double> values = nextForce.getRecordValues(s); nextRow.getData().append(values); } if(_includeConstraintForces){ // NUMBER OF Constraints const ConstraintSet& constraints = _model->getConstraintSet(); // This does not contain gravity int nc = constraints.getSize(); for(int i=0;i<nc;i++) { OpenSim::Constraint& nextConstraint = (OpenSim::Constraint&)constraints[i]; if (nextConstraint.isDisabled(s)) continue; Array<double> values = nextConstraint.getRecordValues(s); nextRow.getData().append(values); } } _forceStore.append(nextRow); return(0); }
void testPendulumExternalLoadWithPointInGround() { ForwardTool forward("pendulum_ext_point_in_ground_Setup_Forward.xml");cout << endl; forward.run(); Storage results("Results/pendulum_ext_gravity_point_in_ground_states.sto"); ASSERT(results.getFirstTime() == 0.0); ASSERT(results.getLastTime() == 1.0); Storage standard("Results/pendulum_states.sto"); Array<double> data; int i = results.getSize() - 1; StateVector* state = results.getStateVector(i); double time = state->getTime(); data.setSize(state->getSize()); standard.getDataAtTime(time, state->getSize(), data); int nc = forward.getModel().getNumCoordinates(); for (int j = 0; j < nc; ++j) { stringstream message; message << "t=" << time <<" state# "<< j << " " << standard.getColumnLabels()[j+1] << " std=" << data[j] <<" computed=" << state->getData()[j]; ASSERT_EQUAL(data[j], state->getData()[j], 1e-2, __FILE__, __LINE__, "ASSERT_EQUAL FAILED " + message.str()); cout << "ASSERT_EQUAL PASSED " << message.str() << endl; } }
void testGait2354() { ForwardTool forward("subject01_Setup_Forward.xml"); forward.run(); Storage results("Results/subject01_states.sto"); Storage* standard = new Storage(); string statesFileName("std_subject01_walk1_states.sto"); forward.loadStatesStorage( statesFileName, standard ); Array<double> data; StateVector* state = results.getStateVector(0); double time = state->getTime(); data.setSize(state->getSize()); standard->getDataAtTime(time, state->getSize(), data); // At initial time all states should be identical except for locked joints may vary slightly due to // differences in OpenSim's integrator and SimTK's int nc = forward.getModel().getNumCoordinates(); for (int j = 0; j < state->getSize(); ++j) { stringstream message; message << "t=" << time <<" state# "<< j << " " << standard->getColumnLabels()[j+1] << " std=" << data[j] <<" computed=" << state->getData()[j]; ASSERT_EQUAL(data[j], state->getData()[j], 1e-4, __FILE__, __LINE__, "ASSERT_EQUAL FAILED " + message.str()); cout << "ASSERT_EQUAL PASSED " << message.str() << endl;; } int i = results.getSize()-1; state = results.getStateVector(i); time = state->getTime(); standard->getDataAtTime(time, state->getSize(), data); // NOTE: Gait model is running forward open-loop. We cannot expect all the states to // be "bang on" and we expect a gradual drift in the coordinates. Check to see that // coordinates haven't drifted too far off. for (int j = 0; j < nc; ++j) { stringstream message; message << "t=" << time <<" state# "<< j << " " << standard->getColumnLabels()[j+1] << " std=" << data[j] <<" computed=" << state->getData()[j]; ASSERT_EQUAL(data[j], state->getData()[j], 4e-2, __FILE__, __LINE__, "ASSERT_EQUAL FAILED " + message.str()); cout << "ASSERT_EQUAL PASSED " << message.str() << endl; } }