void SpacePlane::init(){
static bool initialized = false;
if(!initialized){
sq_init(modPath() << _SC("models/SpacePlane.nut"),
ModelScaleProcess(modelScale) <<=
SingleDoubleProcess(hitRadius, _SC("hitRadius")) <<=
MassProcess(defaultMass) <<=
SingleDoubleProcess(maxHealthValue, _SC("maxhealth"), false) <<=
Vec3dListProcess(engines, _SC("engines")) <<=
DrawOverlayProcess(overlayDisp)
);
initialized = true;
}
undocktime = 0.f;
health = getMaxHealth();
mass = defaultMass;
people = RandomSequence((unsigned long)this).next() % 100 + 100;
engineHeat = 0.f;
pf.resize(engines.size());
for(int i = 0; i < pf.size(); i++)
pf[i] = NULL;
}
void UHMMCalibrate::calibrateParallel(WorkPool_s *wpool, TaskStateInfo& si) {
HMMERTaskLocalData *tls = getHMMERTaskLocalData();
struct alphabet_s *al = &tls->al;
struct plan7_s *hmm = wpool->hmm;
struct dpmatrix_s *mx = CreatePlan7Matrix(1, hmm->M, 25, 0);
int len;
float sc;
char *seq;
unsigned char *dsq;
while(true) {
/* generate a sequence */
{
QMutexLocker locker(&wpool->lockInput);
wpool->nseq++;
if (wpool->nseq > wpool->nsample) { /* we're done; release input lock, break loop */
break;
}
if (wpool->fixedlen) {
len = wpool->fixedlen;
} else {
do {
len = (int) Gaussrandom(wpool->lenmean, wpool->lensd);
} while (len < 1);
}
seq = RandomSequence(al->Alphabet, wpool->randomseq.data(), al->Alphabet_size, len);
}
/* compute score */
dsq = DigitizeSequence(seq, len);
if (P7ViterbiSpaceOK(len, hmm->M, mx)) {
sc = P7Viterbi(dsq, len, hmm, mx, NULL);
} else {
int pStub;
sc = P7SmallViterbi(dsq, len, hmm, mx, NULL, pStub);
}
free(dsq);
free(seq);
/* save output */
QMutexLocker locker(&wpool->lockOutput);
AddToHistogram(wpool->hist, sc);
wpool->max_score = qMax(wpool->max_score, sc);
si.progress = int(100*wpool->nseq/float(wpool->nsample)); //TODO: update progress for all tasks?
if (wpool->progress!=NULL) {
*wpool->progress = si.progress;
}
}
FreePlan7Matrix(mx);
}
/* Function: main_loop_serial()
* Date: SRE, Tue Aug 18 16:18:28 1998 [St. Louis]
*
* Purpose: Given an HMM and parameters for synthesizing random
* sequences; return a histogram of scores.
* (Serial version)
*
* Args: hmm - an HMM to calibrate.
* seed - random number seed
* nsample - number of seqs to synthesize
* lenmean - mean length of random sequence
* lensd - std dev of random seq length
* fixedlen - if nonzero, override lenmean, always this len
* ret_hist - RETURN: the score histogram
* ret_max - RETURN: highest score seen in simulation
*
* Returns: (void)
* hist is alloc'ed here, and must be free'd by caller.
*/
static void
main_loop_serial(struct plan7_s *hmm, int seed, int nsample,
float lenmean, float lensd, int fixedlen,
struct histogram_s **ret_hist, float *ret_max)
{
struct histogram_s *hist;
float randomseq[MAXABET];
float p1;
float max;
char *seq;
char *dsq;
float score;
int sqlen;
int idx;
/* Initialize.
* We assume we've already set the alphabet (safe, because
* HMM input sets the alphabet).
*/
sre_srandom(seed);
P7Logoddsify(hmm, TRUE);
P7DefaultNullModel(randomseq, &p1);
hist = AllocHistogram(-200, 200, 100);
max = -FLT_MAX;
for (idx = 0; idx < nsample; idx++)
{
/* choose length of random sequence */
if (fixedlen) sqlen = fixedlen;
else do sqlen = (int) Gaussrandom(lenmean, lensd); while (sqlen < 1);
/* generate it */
seq = RandomSequence(Alphabet, randomseq, Alphabet_size, sqlen);
dsq = DigitizeSequence(seq, sqlen);
if (P7ViterbiSize(sqlen, hmm->M) <= RAMLIMIT)
score = P7Viterbi(dsq, sqlen, hmm, NULL);
else
score = P7SmallViterbi(dsq, sqlen, hmm, NULL);
AddToHistogram(hist, score);
if (score > max) max = score;
free(dsq);
free(seq);
}
*ret_hist = hist;
*ret_max = max;
return;
}
static void main_loop_serial(struct plan7_s *hmm, int seed, int nsample,
float lenmean, float lensd, int fixedlen,
struct histogram_s **ret_hist, float *ret_max, int& cancelFlag, int& progress)
{
struct histogram_s *hist;
struct dpmatrix_s *mx;
float randomseq[MAXABET];
float p1;
float max;
char *seq;
unsigned char *dsq;
float score;
int sqlen;
int idx;
// Initialize.
// We assume we've already set the alphabet (safe, because
// HMM input sets the alphabet).
sre_srandom(seed);
//get HMMERTaskLocalData
HMMERTaskLocalData *tls = getHMMERTaskLocalData();
alphabet_s &al = tls->al;
SetAlphabet(hmm->atype);
P7Logoddsify(hmm, TRUE);
P7DefaultNullModel(randomseq, &p1);
hist = AllocHistogram(-200, 200, 100);
mx = CreatePlan7Matrix(1, hmm->M, 25, 0);
max = -FLT_MAX;
progress = 0;
int pStub;
for (idx = 0; idx < nsample && !cancelFlag; idx++) {
// choose length of random sequence
if (fixedlen) {
sqlen = fixedlen;
} else {
do sqlen = (int) Gaussrandom(lenmean, lensd); while (sqlen < 1);
}
// generate it
seq = RandomSequence(al.Alphabet, randomseq, al.Alphabet_size, sqlen);
dsq = DigitizeSequence(seq, sqlen);
if (P7ViterbiSpaceOK(sqlen, hmm->M, mx)) {
score = P7Viterbi(dsq, sqlen, hmm, mx, NULL);
} else {
score = P7SmallViterbi(dsq, sqlen, hmm, mx, NULL, pStub);
}
AddToHistogram(hist, score);
max = qMax(score, max);
progress = int(100*idx/float(nsample));
free(dsq);
free(seq);
}
FreePlan7Matrix(mx);
*ret_hist = hist;
*ret_max = max;
}
int
main(void)
{
int master_tid; /* PVM TID of our master */
int slaveidx; /* my slave index (0..nslaves-1) */
struct plan7_s *hmm; /* HMM to calibrate, sent from master */
struct histogram_s *hist; /* score histogram */
int hmmidx; /* index of this HMM */
char *seq; /* synthetic random sequence */
char *dsq; /* digitized seq */
int len; /* length of seq */
float sc; /* score of seq aligned to HMM */
float max; /* maximum score seen in sample */
int seed; /* random number seed */
int nsample; /* number of seqs to sample */
int fixedlen; /* if nonzero, fixed length of seq */
float lenmean; /* Gaussian mean length of seq */
float lensd; /* Gaussian length std. dev. for seq */
int fitok; /* TRUE if EVD fit was OK */
float randomseq[MAXABET]; /* iid frequencies of residues */
float p1;
int alphatype; /* alphabet type, hmmAMINO or hmmNUCLEIC */
int idx;
int code;
/* Register leave_pvm() cleanup function so any exit() call
* first calls pvm_exit().
*/
if (atexit(leave_pvm) != 0) { pvm_exit(); Die("slave couldn't register leave_pvm()"); }
/*****************************************************************
* initialization.
* Master broadcasts the problem to us: parameters of the
* HMM calibration.
******************************************************************/
master_tid = pvm_parent(); /* who's our master? */
pvm_recv(master_tid, HMMPVM_INIT);
pvm_upkint(&nsample, 1, 1);
pvm_upkint(&fixedlen, 1, 1);
pvm_upkfloat(&lenmean, 1, 1);
pvm_upkfloat(&lensd, 1, 1);
/* tell the master we're OK and ready to go (or not)
*/
code = HMMPVM_OK;
pvm_initsend(PvmDataDefault);
pvm_pkint(&code, 1, 1);
pvm_send(master_tid, HMMPVM_RESULTS);
/*****************************************************************
* Main loop.
* Receive a random number seed, then an HMM to search against.
* If we receive a -1 seed, we shut down.
*****************************************************************/
slaveidx = -1;
for (;;)
{
pvm_recv(master_tid, HMMPVM_WORK);
pvm_upkint(&seed, 1, 1);
if (seed == -1) break; /* shutdown signal */
pvm_upkint(&hmmidx, 1, 1);
pvm_upkint(&alphatype,1, 1);
SetAlphabet(alphatype);
hmm = PVMUnpackHMM();
if (hmm == NULL) Die("oh no, the HMM never arrived");
if (slaveidx == -1) slaveidx = hmmidx;
P7DefaultNullModel(randomseq, &p1);
sre_srandom(seed);
P7Logoddsify(hmm, TRUE);
hist = AllocHistogram(-200, 200, 100);
max = -FLT_MAX;
for (idx = 0; idx < nsample; idx++)
{
/* choose length of random sequence */
if (fixedlen) len = fixedlen;
else do len = (int) Gaussrandom(lenmean, lensd); while (len < 1);
/* generate it */
seq = RandomSequence(Alphabet, randomseq, Alphabet_size, len);
dsq = DigitizeSequence(seq, len);
if (P7ViterbiSize(len, hmm->M) <= RAMLIMIT)
sc = P7Viterbi(dsq, len, hmm, NULL);
else
sc = P7SmallViterbi(dsq, len, hmm, NULL);
AddToHistogram(hist, sc);
if (sc > max) max = sc;
free(seq);
free(dsq);
}
/* Fit an EVD to the observed histogram.
* The TRUE left-censors and fits only the right slope of the histogram.
* The 9999. is an arbitrary high number that means we won't trim outliers
* on the right.
*/
fitok = ExtremeValueFitHistogram(hist, TRUE, 9999.);
/* Return output to master.
* Currently we don't send the histogram back, but we could.
*/
pvm_initsend(PvmDataDefault);
pvm_pkint(&slaveidx, 1, 1);
pvm_pkint(&hmmidx, 1, 1);
PVMPackString(hmm->name);
pvm_pkint(&fitok, 1, 1);
pvm_pkfloat(&(hist->param[EVD_MU]), 1, 1);
pvm_pkfloat(&(hist->param[EVD_LAMBDA]), 1, 1);
pvm_pkfloat(&max, 1, 1);
pvm_send(master_tid, HMMPVM_RESULTS);
/* cleanup
*/
FreeHistogram(hist);
FreePlan7(hmm);
}
/***********************************************
* Cleanup, return.
***********************************************/
return 0; /* pvm_exit() is called by atexit() registration. */
}
/* Function: worker_thread()
* Date: SRE, Thu Jul 16 10:41:02 1998 [St. Louis]
*
* Purpose: The procedure executed by the worker threads.
*
* Args: ptr - (void *) that is recast to a pointer to
* the workpool.
*
* Returns: (void *)
*/
void *
worker_thread(void *ptr)
{
struct plan7_s *hmm;
struct workpool_s *wpool;
char *seq;
char *dsq;
int len;
float sc;
int rtn;
Stopwatch_t thread_watch;
StopwatchStart(&thread_watch);
wpool = (struct workpool_s *) ptr;
hmm = wpool->hmm;
for (;;)
{
/* 1. Synthesize a random sequence.
* The input sequence number is a shared resource,
* and sre_random() isn't thread-safe, so protect
* the whole section with mutex.
*/
/* acquire a lock */
if ((rtn = pthread_mutex_lock(&(wpool->input_lock))) != 0)
Die("pthread_mutex_lock failure: %s\n", strerror(rtn));
/* generate a sequence */
wpool->nseq++;
if (wpool->nseq > wpool->nsample)
{ /* we're done; release input lock, break loop */
if ((rtn = pthread_mutex_unlock(&(wpool->input_lock))) != 0)
Die("pthread_mutex_unlock failure: %s\n", strerror(rtn));
break;
}
if (wpool->fixedlen) len = wpool->fixedlen;
else do len = (int) Gaussrandom(wpool->lenmean, wpool->lensd); while (len < 1);
seq = RandomSequence(Alphabet, wpool->randomseq, Alphabet_size, len);
/* release the lock */
if ((rtn = pthread_mutex_unlock(&(wpool->input_lock))) != 0)
Die("pthread_mutex_unlock failure: %s\n", strerror(rtn));
/* 2. Score the sequence against the model.
*/
dsq = DigitizeSequence(seq, len);
if (P7ViterbiSize(len, hmm->M) <= RAMLIMIT)
sc = P7Viterbi(dsq, len, hmm, NULL);
else
sc = P7SmallViterbi(dsq, len, hmm, NULL);
free(dsq);
free(seq);
/* 3. Save the output; hist and max_score are shared,
* so protect this section with the output mutex.
*/
/* acquire lock on the output queue */
if ((rtn = pthread_mutex_lock(&(wpool->output_lock))) != 0)
Die("pthread_mutex_lock failure: %s\n", strerror(rtn));
/* save output */
AddToHistogram(wpool->hist, sc);
if (sc > wpool->max_score) wpool->max_score = sc;
/* release our lock */
if ((rtn = pthread_mutex_unlock(&(wpool->output_lock))) != 0)
Die("pthread_mutex_unlock failure: %s\n", strerror(rtn));
}
StopwatchStop(&thread_watch);
/* acquire lock on the output queue */
if ((rtn = pthread_mutex_lock(&(wpool->output_lock))) != 0)
Die("pthread_mutex_lock failure: %s\n", strerror(rtn));
/* accumulate cpu time into main stopwatch */
StopwatchInclude(&(wpool->watch), &thread_watch);
/* release our lock */
if ((rtn = pthread_mutex_unlock(&(wpool->output_lock))) != 0)
Die("pthread_mutex_unlock failure: %s\n", strerror(rtn));
pthread_exit(NULL);
return NULL; /* solely to silence compiler warnings */
}
int main(int argc, char *argv[]) {
struct sigaction sig;
int StationSeq[SENSOR_MAX_NUM];
int sfd, maxWait, i, j, rand;
int anzSensors;
char buf[BUF_SIZE];
SensorData sensor;
float deltaT;
float tempPreset[8] = {20, 45, 30, 20, 15, 10, 15, 20};
float startup[8] = {0, 0, 0, 0, 0, 0, 0, 0};
int sequenceNr[8] = {0, 0, 0, 0, 0, 0, 0, 0};
//*** check for hostname ... a kind of hack
if (argc < 4) {
printf("Need number of devices, hostname or IP address and port number\n");
exit(-1);
}
if ((anzSensors = numOfSensors(atoi(argv[1]))) < 0) {
printf("\n*** invalid number of sensor devices ***\n\n");
exit(0);
}
// set up signal handlers
sigemptyset(&sig.sa_mask);
sig.sa_handler = SignalHandler;
sig.sa_flags = 0;
sigaction(SIGTERM, &sig, NULL);
sigaction(SIGKILL, &sig, NULL);
sigaction(SIGINT, &sig, NULL);
sleep(2);
printf("Sensor device starting up\n");
globalK = 0;
while (globalK < MAX_ITERATIONS) {
RandomSequence(StationSeq, anzSensors);
for (i = 0; i < anzSensors; i++) { // for all devices
deltaT = intRand(-2, 2);
sensor.deviceID = StationSeq[i];
sensor.sequenceNr = sequenceNr[sensor.deviceID];
sensor.valIS = deltaT + startup[sensor.deviceID];
sensor.valREF = tempPreset[sensor.deviceID];
sensor.status = 0;
sequenceNr[sensor.deviceID]++;
sfd = connToServer(argv[2], atoi(argv[3]));
write(sfd, (char *)&sensor,sizeof(SensorData));
close(sfd);
maxWait = 4000000;
maxWait = maxWait / anzSensors;
rand = intRand(maxWait/3, maxWait);
usleep(rand);
}
for (j = 0; j < anzSensors; j++) {
if (startup[j] < tempPreset[j])
startup[j] += 2;
else
startup[j] = tempPreset[j];
}
globalK++;
}
exit(0);
} // end main
