Example #1
0
	TPThread(ThreadPool* threadPool, int threadWaitSecond = 0):
	threadWaitSecond_(threadWaitSecond), 
	currTask_(NULL), 
	threadPool_(threadPool)
	{
		state_ = THREAD_STATE_SLEEP;
		initCond();
		initMutex();
	}
			PosixConditionSemaphore() : sigcnt(0)
			{
				initCond();
				try
				{
					initMutex();
				}
				catch(...)
				{
					pthread_cond_destroy(&cond);
					throw;
				}
			}
                        TerminatableSynchronousReorderSet(uint64_t const rnext = 0)
                        : numwait(0), Q(), terminated(false), next(rnext)
                        {
				initCond();
				try
				{
					initMutex();
				}
				catch(...)
				{
					pthread_cond_destroy(&cond);
					throw;
				}                        
                        }
Example #4
0
/**
 * Create the underlying system component(s).
 */
void Probe::addToSystem(MultibodySystem& system) const
{
    Super::addToSystem(system);

    if (isDisabled())
        return;

    // Make writable briefly so we can finalize the Probe to include 
    // references to the allocated System resources.
    Probe* mutableThis = const_cast<Probe*>(this);

    // ---------------------------------------------------------------------
    // Create a <double> Measure of the value to be probed (operand).
    // For now, this is scalarized, i.e. a separate Measure is created
    // for each probe input element in the Vector.
    // ---------------------------------------------------------------------
    // save for when we can directly operate on Vector SimTK::Measures
    //ProbeMeasure<SimTK::Vector> beforeOperationValueVector(system, *this);

	int npi = getNumProbeInputs();
    SimTK::Array_<ProbeMeasure<double> > beforeOperationValues;
    mutableThis->afterOperationValues.resize(npi);

    for (int i=0; i<npi; ++i) {
        ProbeMeasure<double> tmpPM(system, *this, i); 
        beforeOperationValues.push_back(tmpPM);
    }



    // Assign the correct (operation) Measure subclass to the operand
    // ==============================================================

    // ---------------------------------------------------------------------
    // Return the original probe value (no operation)
    // ---------------------------------------------------------------------
    if (getOperation() == "value") {
        for (int i=0; i<npi; ++i) {
            mutableThis->afterOperationValues[i] = beforeOperationValues[i];   
        }
    }


    // ---------------------------------------------------------------------
    // Integrate the probe value
    // ---------------------------------------------------------------------
    else if (getOperation() == "integrate") {
        // check to see that size of initial condition vector
        // is the same size as the data being integrated.
        if (getInitialConditions().size() != getProbeOutputLabels().getSize())  {
            stringstream errorMessage;
            errorMessage << getConcreteClassName() << "(" + getName() << 
                "): Mismatch between the size of the data labels corresponding to the "
                "size of the data vector being integrated (" 
                <<  getProbeOutputLabels().getSize() 
                << ") and size of initial conditions vector (" 
                << getInitialConditions().size() << ").\nAssuming an initial condition vector of " 
                << getProbeOutputLabels().getSize() << " zeros." << endl;
            cout << errorMessage.str() << endl;

            SimTK::Vector newInitCond(getProbeOutputLabels().getSize());
            newInitCond = 0;
            Probe* mutableThis = const_cast<Probe*>(this);
            mutableThis->setInitialConditions(newInitCond);

            //throw (Exception(errorMessage.str()));
        }

        for (int i=0; i<getNumProbeInputs(); ++i) {
            //Measure::Constant initCond(system, getInitialConditions()(i));  // init cond is handled as a special case in getProbeOutputs()
            Measure::Constant initCond(system, 0.0);
            mutableThis->afterOperationValues[i] = Measure::Integrate(
                system, beforeOperationValues[i], initCond);
        }
    }


    // ---------------------------------------------------------------------
    // Differentiate the probe value
    // ---------------------------------------------------------------------
    else if (getOperation() == "differentiate") {
        for (int i=0; i<getNumProbeInputs(); ++i) {
            mutableThis->afterOperationValues[i] = Measure::Differentiate(
                system, beforeOperationValues[i]);
        }
    }


    // ---------------------------------------------------------------------
    // Get the minimum of the probe value
    // ---------------------------------------------------------------------
    else if (getOperation() == "minimum") {
        for (int i=0; i<getNumProbeInputs(); ++i) {
            mutableThis->afterOperationValues[i] = Measure::Minimum(
                system, beforeOperationValues[i]);
        }
    }


    // ---------------------------------------------------------------------
    // Get the absolute minimum of the probe value
    // ---------------------------------------------------------------------
    else if (getOperation() == "minabs") {
        for (int i=0; i<getNumProbeInputs(); ++i) {
            mutableThis->afterOperationValues[i] = Measure::MinAbs(
                system, beforeOperationValues[i]);
        }
    }
    	

    // ---------------------------------------------------------------------
    // Get the maximum of the probe value
    // ---------------------------------------------------------------------
    else if (getOperation() == "maximum") {
        for (int i=0; i<getNumProbeInputs(); ++i) {
            mutableThis->afterOperationValues[i] = Measure::Maximum(
                system, beforeOperationValues[i]);
        }
    }


    // ---------------------------------------------------------------------
    // Get the absolute maximum of the probe value
    // ---------------------------------------------------------------------
    else if (getOperation() == "maxabs") {
        for (int i=0; i<getNumProbeInputs(); ++i) {
            mutableThis->afterOperationValues[i] = Measure::MaxAbs(
                system, beforeOperationValues[i]);
        }
    }


    // ---------------------------------------------------------------------
    // Throw exception (invalid operation)
    // ---------------------------------------------------------------------
    else {
        stringstream errorMessage;
        errorMessage << getConcreteClassName() << ": Invalid probe operation: " 
            << getOperation() 
            << ". Currently supports 'value', 'integrate', 'differentiate', "
            "'minimum', 'minabs', 'maximum', 'maxabs'." << endl;
        throw (Exception(errorMessage.str()));
    }

}