int Loop::getIndexOfNote(int noteNumber, double time, bool exact)
{
if (!exact) {
for (int i=0;i<getNumEvents();i++)
{
if (getEventPointer(i)->message.isNoteOn()
&& getEventPointer(i)->message.getNoteNumber()==noteNumber
&& (getEventTime(i)<=time && getTimeOfMatchingKeyUp(i)>time))
{
return i;
}
}
}
else {
for (int i=0;i<getNumEvents();i++)
{
if (getEventPointer(i)->message.isNoteOn()
&& getEventPointer(i)->message.getNoteNumber()==noteNumber
&& fabs(getEventTime(i)-time)<1.0)
{
return i;
}
}
}
return No_Note;
}
void Loop::cleanZeroLengthNotes()
{
Array<int> matchedNoteOffs;
for (int i=0;i<getNumEvents();i++)
{
if (getEventPointer(i)->message.isNoteOn())
{
if (getEventTime(i) == getTimeOfMatchingKeyUp(i) || getTimeOfMatchingKeyUp(i)==0.0)
{
//zero length note
deleteEvent(i,(getTimeOfMatchingKeyUp(i)!=0.0));
updateMatchedPairs();
}
}
}
for (int i=0;i<getNumEvents();i++)
{
if (getEventPointer(i)->message.isNoteOn() && getIndexOfMatchingKeyUp(i)!=-1)
matchedNoteOffs.add(getIndexOfMatchingKeyUp(i));
}
for (int i=0;i<getNumEvents();i++)
{
if (getEventPointer(i)->message.isNoteOff() && !matchedNoteOffs.contains(i)) {
//unmatched note-off
deleteEvent(i,false);
updateMatchedPairs();
break;
}
}
//updateMatchedPairs();
}
bool Loop::findNextNote()
{
if (currentIndex>=getNumEvents())
currentIndex=0;
if (this->getEventPointer(currentIndex)->message.isNoteOn())
{
return true;
}
++currentIndex;
while (currentIndex<getNumEvents())
{
if (this->getEventPointer(currentIndex)->message.isNoteOn())
{
return true;
}
++currentIndex;
}
currentIndex=0;
while (currentIndex<getNumEvents())
{
if (this->getEventPointer(currentIndex)->message.isNoteOn())
{
return true;
}
++currentIndex;
}
return false;
}
void
Model::dealWithEvents(bool strict)
{
// if strict conversion want to unset L3 prioirty
if (strict == true)
{
if (getNumEvents() > 0)
{
for (unsigned int i = 0; i < getNumEvents(); i++)
{
Event * e = getEvent(i);
e->unsetPriority();
}
}
}
}
bool GHOST_EventManager::dispatchEvents()
{
bool handled;
if (getNumEvents()) {
handled = true;
while (getNumEvents()) {
if (!dispatchEvent()) {
handled = false;
}
}
}
else {
handled = false;
}
return handled;
}
void ReflexiveContainer::disconnectAll(void)
{
for(UInt32 i(0) ; i<getNumEvents() ; ++i)
{
disconnectAllSlotsEvent(i+1);
}
}
void EventHeader::toStream( std::ostream &stream )
{
stream.write( reinterpret_cast<const char*>(&m_mode), 1 );
// convert number of events to 24bit little endian representation
uint32 numev = getNumEvents( );
uint8 tmp[3];
tmp[0] = numev % 256;
tmp[1] = (numev / 256) % 256;
tmp[2] = (numev / 65536) % 256;
stream.write( reinterpret_cast<const char*>(tmp), 3 );
writeLittleEndian( stream, getSamplingRate( ) );
if( getMode() == 1 )
{
Mode1Event e;
// write event positions
for( size_t i=0; i<getNumEvents(); i++)
{
getEvent( i, e );
writeLittleEndian( stream, e.position );
}
// write event types
for( size_t i=0; i<getNumEvents(); i++)
{
getEvent( i, e );
writeLittleEndian( stream, e.type );
}
}
else if( getMode() == 3 )
{
Mode3Event e;
// write event positions
for( size_t i=0; i<getNumEvents(); i++)
{
getEvent( i, e );
writeLittleEndian( stream, e.position );
}
// write event types
for( size_t i=0; i<getNumEvents(); i++)
{
getEvent( i, e );
writeLittleEndian( stream, e.type );
}
// write event channels
for( size_t i=0; i<getNumEvents(); i++)
{
getEvent( i, e );
writeLittleEndian( stream, e.channel );
}
// write event durations
for( size_t i=0; i<getNumEvents(); i++)
{
getEvent( i, e );
writeLittleEndian( stream, e.duration );
}
}
}
/*----------------------------------------------------------------------------------------------------------------------
| Returns a vector of univent states for site `site'. Assumes `is_valid' is true and `site' is less than the length of
| the `univents' vector. This function is not particularly efficient, and it intended primarily for transferring
| univent states to Python code for debugging purposes.
*/
std::vector<unsigned> Univents::getEventsVec(
unsigned site) const /**< is the site of interest */
{
PHYCAS_ASSERT(is_valid);
std::vector<unsigned> v(getNumEvents(site));
const StateMapping & u = univents.at(site);
unsigned i = 0;
for (StateMapping::const_iterator it = u.begin(); it != u.end(); ++it, ++i)
v[i] = (unsigned)*it;
return v;
}
// Generate a header event
bool
WriteUserLogHeader::GenerateEvent( GenericEvent &event )
{
int len = snprintf( event.info, COUNTOF(event.info),
"Global JobLog:"
" ctime=%d"
" id=%s"
" sequence=%d"
" size=" FILESIZE_T_FORMAT""
" events=%" PRId64""
" offset=" FILESIZE_T_FORMAT""
" event_off=%" PRId64""
" max_rotation=%d"
" creator_name=<%s>",
(int) getCtime(),
getId().Value(),
getSequence(),
getSize(),
getNumEvents(),
getFileOffset(),
getEventOffset(),
getMaxRotation(),
getCreatorName().Value()
);
if (len < 0 || len == sizeof(event.info)) {
// not enough room in the buffer
len = (int)COUNTOF(event.info)-1;
event.info[len] = 0; // make sure it's null terminated.
::dprintf( D_FULLDEBUG, "Generated (truncated) log header: '%s'\n", event.info );
} else {
::dprintf( D_FULLDEBUG, "Generated log header: '%s'\n", event.info );
while( len < 256 ) {
event.info[len++] = ' ';
event.info[len] = 0;
}
}
return true;
}
void Loop::convertTimeBase(short timeBase)
{
if (timeBase>0 && timeBase!=960)
{
double factor = 960.0/(double)timeBase;
for (int i=0;i<getNumEvents();i++)
{
getEventPointer(i)->message.setTimeStamp(getEventPointer(i)->message.getTimeStamp()*factor);
}
}
else {
/* SMTPE
If it's negative, the upper byte indicates the frames-per-second (but negative), and
the lower byte is the number of ticks per frame - see setSmpteTimeFormat().
@param framesPerSecond must be 24, 25, 29 or 30
@param subframeResolution the sub-second resolution, e.g. 4 (midi time code),
8, 10, 80 (SMPTE bit resolution), or 100. For millisecond
timing, setSmpteTimeFormat (25, 40)
*/
int framesPerSecond = -(timeBase / 0x100);
int subframeResolution = (timeBase & 0x00ff);
}
}
void
Model::removeDuplicateTopLevelAnnotations()
{
unsigned int i, n;
this->removeDuplicateAnnotations();
if (getNumFunctionDefinitions() > 0)
{
getListOfFunctionDefinitions()->removeDuplicateAnnotations();
for (i = 0; i < getNumFunctionDefinitions(); i++)
{
getFunctionDefinition(i)->removeDuplicateAnnotations();
}
}
if (getNumUnitDefinitions() > 0)
{
getListOfUnitDefinitions()->removeDuplicateAnnotations();
for (i = 0; i < getNumUnitDefinitions(); i++)
{
getUnitDefinition(i)->removeDuplicateAnnotations();
getUnitDefinition(i)->getListOfUnits()->removeDuplicateAnnotations();
for (n = 0; n < getUnitDefinition(i)->getNumUnits(); n++)
{
getUnitDefinition(i)->getUnit(n)->removeDuplicateAnnotations();
}
}
}
if (getNumCompartmentTypes() > 0)
{
getListOfCompartmentTypes()->removeDuplicateAnnotations();
for (i = 0; i < getNumCompartmentTypes(); i++)
{
getCompartmentType(i)->removeDuplicateAnnotations();
}
}
if (getNumSpeciesTypes() > 0)
{
getListOfSpeciesTypes()->removeDuplicateAnnotations();
for (i = 0; i < getNumSpeciesTypes(); i++)
{
getSpeciesType(i)->removeDuplicateAnnotations();
}
}
if (getNumCompartments() > 0)
{
getListOfCompartments()->removeDuplicateAnnotations();
for (i = 0; i < getNumCompartments(); i++)
{
getCompartment(i)->removeDuplicateAnnotations();
}
}
if (getNumSpecies() > 0)
{
getListOfSpecies()->removeDuplicateAnnotations();
for (i = 0; i < getNumSpecies(); i++)
{
getSpecies(i)->removeDuplicateAnnotations();
}
}
if (getNumParameters() > 0)
{
getListOfParameters()->removeDuplicateAnnotations();
for (i = 0; i < getNumParameters(); i++)
{
getParameter(i)->removeDuplicateAnnotations();
}
}
if (getNumInitialAssignments() > 0)
{
getListOfInitialAssignments()->removeDuplicateAnnotations();
for (i = 0; i < getNumInitialAssignments(); i++)
{
getInitialAssignment(i)->removeDuplicateAnnotations();
}
}
if (getNumConstraints() > 0)
{
getListOfConstraints()->removeDuplicateAnnotations();
for (i = 0; i < getNumConstraints(); i++)
{
getConstraint(i)->removeDuplicateAnnotations();
}
}
if (getNumRules() > 0)
{
getListOfRules()->removeDuplicateAnnotations();
for (i = 0; i < getNumRules(); i++)
{
getRule(i)->removeDuplicateAnnotations();
}
}
if (getNumReactions() > 0)
{
getListOfReactions()->removeDuplicateAnnotations();
for (i = 0; i < getNumReactions(); i++)
{
Reaction * r = getReaction(i);
r->removeDuplicateAnnotations();
if (r->getNumReactants() > 0)
{
r->getListOfReactants()->removeDuplicateAnnotations();
for (n = 0; n < r->getNumReactants(); n++)
{
r->getReactant(n)->removeDuplicateAnnotations();
}
}
if (r->getNumProducts() > 0)
{
r->getListOfProducts()->removeDuplicateAnnotations();
for (n = 0; n < r->getNumProducts(); n++)
{
r->getProduct(n)->removeDuplicateAnnotations();
}
}
if (r->getNumModifiers() > 0)
{
r->getListOfModifiers()->removeDuplicateAnnotations();
for (n = 0; n < r->getNumModifiers(); n++)
{
r->getModifier(n)->removeDuplicateAnnotations();
}
}
if (r->isSetKineticLaw())
{
r->getKineticLaw()->removeDuplicateAnnotations();
if (r->getKineticLaw()->getNumParameters() > 0)
{
r->getKineticLaw()->getListOfParameters()
->removeDuplicateAnnotations();
for (n = 0; n < r->getKineticLaw()->getNumParameters(); n++)
{
r->getKineticLaw()->getParameter(n)->removeDuplicateAnnotations();
}
}
}
}
}
if (getNumEvents() > 0)
{
getListOfEvents()->removeDuplicateAnnotations();
for (i = 0; i < getNumEvents(); i++)
{
getEvent(i)->removeDuplicateAnnotations();
if (getEvent(i)->getNumEventAssignments() > 0)
{
getEvent(i)->getListOfEventAssignments()->removeDuplicateAnnotations();
for (n = 0; n < getEvent(i)->getNumEventAssignments(); n++)
{
getEvent(i)->getEventAssignment(n)->removeDuplicateAnnotations();
}
}
}
}
}
void
Model::removeSBOTermsNotInL2V2(bool strict)
{
unsigned int n, i;
if (strict == true)
{
for (n = 0; n < getNumUnitDefinitions(); n++)
{
getUnitDefinition(n)->unsetSBOTerm();
for (i = 0; i < getUnitDefinition(n)->getNumUnits(); i++)
{
getUnitDefinition(n)->getUnit(i)->unsetSBOTerm();
}
}
for (n = 0; n < getNumCompartments(); n++)
{
getCompartment(n)->unsetSBOTerm();
}
for (n = 0; n < getNumSpecies(); n++)
{
getSpecies(n)->unsetSBOTerm();
}
for (n = 0; n < getNumCompartmentTypes(); n++)
{
getCompartmentType(n)->unsetSBOTerm();
}
for (n = 0; n < getNumSpeciesTypes(); n++)
{
getSpeciesType(n)->unsetSBOTerm();
}
for (n = 0; n < getNumReactions(); n++)
{
for (i = 0; i < getReaction(n)->getNumReactants(); i++)
{
if (getReaction(n)->getReactant(i)->isSetStoichiometryMath())
{
getReaction(n)->getReactant(i)->getStoichiometryMath()->unsetSBOTerm();
}
}
for (i = 0; i < getReaction(n)->getNumProducts(); i++)
{
if (getReaction(n)->getProduct(i)->isSetStoichiometryMath())
{
getReaction(n)->getProduct(i)->getStoichiometryMath()->unsetSBOTerm();
}
}
}
for (n = 0; n < getNumEvents(); n++)
{
if (getEvent(n)->isSetTrigger())
{
getEvent(n)->getTrigger()->unsetSBOTerm();
}
if (getEvent(n)->isSetDelay())
{
getEvent(n)->getDelay()->unsetSBOTerm();
}
}
}
}
void
Model::removeSBOTerms(bool strict)
{
unsigned int n, i;
if (strict == true)
{
unsetSBOTerm();
for (n = 0; n < getNumUnitDefinitions(); n++)
{
getUnitDefinition(n)->unsetSBOTerm();
for (i = 0; i < getUnitDefinition(n)->getNumUnits(); i++)
{
getUnitDefinition(n)->getUnit(i)->unsetSBOTerm();
}
}
for (n = 0; n < getNumCompartments(); n++)
{
getCompartment(n)->unsetSBOTerm();
}
for (n = 0; n < getNumSpecies(); n++)
{
getSpecies(n)->unsetSBOTerm();
}
for (n = 0; n < getNumParameters(); n++)
{
getParameter(n)->unsetSBOTerm();
}
for (n = 0; n < getNumRules(); n++)
{
getRule(n)->unsetSBOTerm();
}
for (n = 0; n < getNumReactions(); n++)
{
getReaction(n)->unsetSBOTerm();
for (i = 0; i < getReaction(n)->getNumReactants(); i++)
{
getReaction(n)->getReactant(i)->unsetSBOTerm();
if (getReaction(n)->getReactant(i)->isSetStoichiometryMath())
{
getReaction(n)->getReactant(i)->getStoichiometryMath()->unsetSBOTerm();
}
}
for (i = 0; i < getReaction(n)->getNumProducts(); i++)
{
getReaction(n)->getProduct(i)->unsetSBOTerm();
if (getReaction(n)->getProduct(i)->isSetStoichiometryMath())
{
getReaction(n)->getProduct(i)->getStoichiometryMath()->unsetSBOTerm();
}
}
for (i = 0; i < getReaction(n)->getNumModifiers(); i++)
{
getReaction(n)->getModifier(i)->unsetSBOTerm();
}
if (getReaction(n)->isSetKineticLaw())
{
getReaction(n)->getKineticLaw()->unsetSBOTerm();
}
}
for (n = 0; n < getNumFunctionDefinitions(); n++)
{
getFunctionDefinition(n)->unsetSBOTerm();
}
for (n = 0; n < getNumEvents(); n++)
{
getEvent(n)->unsetSBOTerm();
for (i = 0; i < getEvent(n)->getNumEventAssignments(); i++)
{
getEvent(n)->getEventAssignment(i)->unsetSBOTerm();
}
if (getEvent(n)->isSetTrigger())
{
getEvent(n)->getTrigger()->unsetSBOTerm();
}
if (getEvent(n)->isSetDelay())
{
getEvent(n)->getDelay()->unsetSBOTerm();
}
}
}
}
void
Model::assignRequiredValues()
{
// when converting to L3 some attributes which have default values in L1/L2
// but are required in L3 are not present or set
unsigned int i, n;
if (getNumUnitDefinitions() > 0)
{
for (i = 0; i < getNumUnitDefinitions(); i++)
{
for (n = 0; n < getUnitDefinition(i)->getNumUnits(); n++)
{
Unit *u = getUnitDefinition(i)->getUnit(n);
if (!u->isSetExponent())
u->setExponent(1.0);
if (!u->isSetScale())
u->setScale(0);
if (!u->isSetMultiplier())
u->setMultiplier(1.0);
}
}
}
if (getNumCompartments() > 0)
{
for (i = 0; i < getNumCompartments(); i++)
{
Compartment *c = getCompartment(i);
c->setConstant(c->getConstant());
}
}
if (getNumSpecies() > 0)
{
for (i = 0; i < getNumSpecies(); i++)
{
Species * s = getSpecies(i);
s->setBoundaryCondition(s->getBoundaryCondition());
s->setHasOnlySubstanceUnits(s->getHasOnlySubstanceUnits());
s->setConstant(s->getConstant());
}
}
if (getNumParameters() > 0)
{
for (i = 0; i < getNumParameters(); i++)
{
Parameter * p = getParameter(i);
p->setConstant(p->getConstant());
}
}
if (getNumReactions() > 0)
{
for (i = 0; i < getNumReactions(); i++)
{
Reaction * r = getReaction(i);
r->setFast(r->getFast());
r->setReversible(r->getReversible());
if (r->getNumReactants() > 0)
{
for (n = 0; n < r->getNumReactants(); n++)
{
SpeciesReference *sr = r->getReactant(n);
if (sr->isSetStoichiometryMath())
{
sr->setConstant(false);
}
else
{
sr->setConstant(true);
}
}
}
if (r->getNumProducts() > 0)
{
for (n = 0; n < r->getNumProducts(); n++)
{
SpeciesReference *sr = r->getProduct(n);
if (sr->isSetStoichiometryMath())
{
sr->setConstant(false);
}
else
{
sr->setConstant(true);
}
}
}
}
}
if (getNumEvents() > 0)
{
for (i = 0; i < getNumEvents(); i++)
{
Event * e = getEvent(i);
e->setUseValuesFromTriggerTime(e->getUseValuesFromTriggerTime());
if (e->isSetTrigger())
{
Trigger *t = e->getTrigger();
t->setPersistent(true);
t->setInitialValue(true);
}
}
}
}
/**
* @brief IntegratePeaksCWSD::simplePeakIntegration
* Purpose:
* Integrate a single crystal peak with the simplest algorithm, i.e.,
* by adding all the signal with normalization to monitor counts
* Requirements:
* Valid MDEventWorkspace
* Valid PeaksWorkspace
* Guarantees:
* A valid value is given
*/
void IntegratePeaksCWSD::simplePeakIntegration(
const std::vector<detid_t> &vecMaskedDetID,
const std::map<int, signal_t> &run_monitor_map) {
// Check requirements
if (!m_inputWS)
throw std::runtime_error("MDEventWorkspace is not defined.");
// Go through to get value
auto mditer = m_inputWS->createIterator();
size_t nextindex = 1;
bool scancell = true;
// size_t currindex = 0;
// Assuming that MDEvents are grouped by run number, there is no need to
// loop up the map for peak center and monitor counts each time
int current_run_number = -1;
signal_t current_monitor_counts = 0;
Kernel::V3D current_peak_center = m_peakCenter;
// signal_t total_signal = 0;
double min_distance = 10000000;
double max_distance = -1;
while (scancell) {
// Go through all the MDEvents in one cell.
size_t numeventincell = mditer->getNumEvents();
for (size_t iev = 0; iev < numeventincell; ++iev) {
// Get signal to add and skip if signal is zero
signal_t signal = mditer->getInnerSignal(iev);
if (signal <= THRESHOLD_SIGNAL)
continue;
uint16_t run_number = mditer->getInnerRunIndex(iev);
int run_number_i = static_cast<int>(run_number);
/* debug: record raw signals
if (run_number_i % 1000 == testrunnumber)
{
total_signal += signal;
++ num_det;
}
// ... debug */
// Check whether this detector is masked
if (!vecMaskedDetID.empty()) {
detid_t detid = mditer->getInnerDetectorID(iev);
std::vector<detid_t>::const_iterator it;
it = find(vecMaskedDetID.begin(), vecMaskedDetID.end(), detid);
if (it != vecMaskedDetID.end()) {
// The detector ID is found among masked detector IDs
// Skip this event and move to next
/* debug: record masked detectors
if (run_number_i % 1000 == testrunnumber)
{
num_masked_det += 1;
g_log.warning() << "Masked detector ID = " << detid << ", Signal = "
<< signal << "\n";
}
// ... debug */
continue;
}
}
/* debug: record unmasked detectors
if (run_number_i % 1000 == testrunnumber)
num_unmasked_det += 1;
// ... debug */
// Check whether to update monitor counts and peak center
if (current_run_number != run_number_i) {
// update run number
current_run_number = run_number_i;
// update monitor counts
if (m_normalizeByMonitor) {
std::map<int, signal_t>::const_iterator m_finder =
run_monitor_map.find(current_run_number);
if (m_finder != run_monitor_map.end())
current_monitor_counts = m_finder->second;
else {
std::stringstream errss;
errss << "Unable to find run number " << current_run_number
<< " in monitor counts map";
throw std::runtime_error(errss.str());
}
} else {
current_monitor_counts = 1.;
}
// update peak center
if (!m_useSinglePeakCenterFmUser)
current_peak_center = m_runPeakCenterMap[current_run_number];
}
// calculate distance
float tempx = mditer->getInnerPosition(iev, 0);
float tempy = mditer->getInnerPosition(iev, 1);
float tempz = mditer->getInnerPosition(iev, 2);
Kernel::V3D pixel_pos(tempx, tempy, tempz);
double distance = current_peak_center.distance(pixel_pos);
/* debug: record unmasked signal
if (run_number_i % 1000 == testrunnumber)
{
total_unmasked_signal += signal;
}
// ... debug */
if (distance < m_peakRadius) {
// FIXME - Is it very costly to use map each time???
// total_signal += signal/current_monitor_counts;
m_runPeakCountsMap[run_number] += signal / current_monitor_counts;
} else {
g_log.debug() << "Out of radius " << distance << " > " << m_peakRadius
<< ": Center = " << current_peak_center.toString()
<< ", Pixel = " << pixel_pos.toString() << "\n";
}
if (distance < min_distance)
min_distance = distance;
if (distance > max_distance)
max_distance = distance;
}
// Advance to next cell
if (mditer->next()) {
// advance to next cell
mditer->jumpTo(nextindex);
++nextindex;
} else {
// break the loop
scancell = false;
}
} // END-WHILE (scan-cell)
// Summarize
g_log.notice() << "Distance range is " << min_distance << ", " << max_distance
<< "\n";
/*
g_log.warning() << "Debug output: run 13: Number masked detectors = " <<
num_masked_det
<< ", Total signal = " << total_signal << "\n";
g_log.warning() << " Number of unmasked detectors = " << num_unmasked_det
<< ", Total unmasked signal = " << total_unmasked_signal <<
"\n";
g_log.warning() << " Number of total detectors = " << num_det << "\n";
*/
}
void PipeBase::processEvents()
{
DWORD dwWait = WaitForMultipleObjects(getNumEvents(), m_hEventsArr, FALSE, 500);
if (isStopped())
return;
if (dwWait == WAIT_TIMEOUT)
return;
if (dwWait == WAIT_FAILED)
{
DWORD lErr = GetLastError();
return;
}
// dwWait shows which pipe completed the operation.
size_t i = dwWait - WAIT_OBJECT_0; // determines which pipe
if (i < 0 || i > (getNumEvents() - 1))
{
printf("Index out of range.\n");
return;
}
PipeData* data = getData(i);
DWORD cbRet = 0;
#ifdef IPC_DEBUG
if (fh)
{
fprintf(fh, "Triggered event %d\n", i);
fflush(fh);
}
#endif
//printf("Event %d, P: %d\n", i, data->fPendingIO);
// Get the result if the operation was pending.
if (data->fPendingIO)
{
BOOL fSuccess = GetOverlappedResult(data->hPipe, &data->oOverlap, &cbRet, FALSE);
//printf("Pending S: %d A: %d P: %d\n", fSuccess, cbRet, data->pendingConnection);
if (data->pendingConnection)
{
if (!fSuccess)
throw gcException(ERR_PIPE, GetLastError(), gcString("Error {0}.\n", GetLastError()));
data->pendingConnection = false;
data->fPendingIO = FALSE;
}
else
{
DWORD err = GetLastError();
//Buffer is full. Wait for space
if (err == ERROR_IO_INCOMPLETE)
fSuccess = GetOverlappedResult(data->hPipe, &data->oOverlap, &cbRet, TRUE);
if (!fSuccess || (cbRet == 0 && data->sender == false)) // || (cbRet != data->size && data->sender == true)
{
disconnectAndReconnect(i);
ResetEvent(m_hEventsArr[i]);
printf("Disconnect pending!\n");
return;
}
if (!data->sender)
{
data->size = cbRet;
finishRead(data, getManager(i));
}
}
}
bool res = false;
// The pipe state determines which operation to do next.
if (data->sender)
res = performWrite(data, getManager(i));
else
res = performRead(data, getManager(i));
if (res)
ResetEvent(m_hEventsArr[i]);
}
/**
* Create an output event workspace filled with data simulated with the fitting
* function.
* @param baseName :: The base name for the workspace
* @param inputWorkspace :: The input workspace.
* @param values :: The calculated values
* @param outputWorkspacePropertyName :: The property name
*/
boost::shared_ptr<API::Workspace> FitMD::createEventOutputWorkspace(
const std::string &baseName, const API::IMDEventWorkspace &inputWorkspace,
const API::FunctionValues &values,
const std::string &outputWorkspacePropertyName) {
auto outputWS =
MDEventFactory::CreateMDWorkspace(inputWorkspace.getNumDims(), "MDEvent");
// Add events
// TODO: Generalize to ND (the current framework is a bit limiting)
auto mdWS = boost::dynamic_pointer_cast<
DataObjects::MDEventWorkspace<DataObjects::MDEvent<4>, 4>>(outputWS);
if (!mdWS) {
return boost::shared_ptr<API::Workspace>();
}
// Bins extents and meta data
for (size_t i = 0; i < 4; ++i) {
boost::shared_ptr<const Geometry::IMDDimension> inputDim =
inputWorkspace.getDimension(i);
Geometry::MDHistoDimensionBuilder builder;
builder.setName(inputDim->getName());
builder.setId(inputDim->getDimensionId());
builder.setUnits(inputDim->getUnits());
builder.setNumBins(inputDim->getNBins());
builder.setMin(inputDim->getMinimum());
builder.setMax(inputDim->getMaximum());
builder.setFrameName(inputDim->getMDFrame().name());
outputWS->addDimension(builder.create());
}
// Run information
outputWS->copyExperimentInfos(inputWorkspace);
// Coordinates
outputWS->setCoordinateSystem(inputWorkspace.getSpecialCoordinateSystem());
// Set sensible defaults for splitting behaviour
BoxController_sptr bc = outputWS->getBoxController();
bc->setSplitInto(3);
bc->setSplitThreshold(3000);
outputWS->initialize();
outputWS->splitBox();
auto inputIter = inputWorkspace.createIterator();
size_t resultValueIndex(0);
const float errorSq = 0.0;
do {
const size_t numEvents = inputIter->getNumEvents();
const float signal =
static_cast<float>(values.getCalculated(resultValueIndex));
for (size_t i = 0; i < numEvents; ++i) {
coord_t centers[4] = {
inputIter->getInnerPosition(i, 0), inputIter->getInnerPosition(i, 1),
inputIter->getInnerPosition(i, 2), inputIter->getInnerPosition(i, 3)};
mdWS->addEvent(MDEvent<4>(signal, errorSq, inputIter->getInnerRunIndex(i),
inputIter->getInnerDetectorID(i), centers));
}
++resultValueIndex;
} while (inputIter->next());
delete inputIter;
// This splits up all the boxes according to split thresholds and sizes.
auto threadScheduler = new Kernel::ThreadSchedulerFIFO();
Kernel::ThreadPool threadPool(threadScheduler);
outputWS->splitAllIfNeeded(threadScheduler);
threadPool.joinAll();
outputWS->refreshCache();
// Store it
if (!outputWorkspacePropertyName.empty()) {
declareProperty(
new API::WorkspaceProperty<API::IMDEventWorkspace>(
outputWorkspacePropertyName, "", Direction::Output),
"Name of the output Workspace holding resulting simulated spectrum");
m_manager->setPropertyValue(outputWorkspacePropertyName,
baseName + "Workspace");
m_manager->setProperty(outputWorkspacePropertyName, outputWS);
}
return outputWS;
}
