/** * 设置 char* ('s') 类型的值 */ void PushStringValue(PluginValue* value, const char* str, uint32_t len) { if (value != nullptr) { value->values.push_back(PValue().SetStringValue(string(str, len))); } }
/** * 设置 void* ('p') 类型的值 */ void PushVoidPtrValue(PluginValue* value, void* vl) { if (value != nullptr) { value->values.push_back(PValue().SetVoidPtrValue(value)); } }
/** * 设置 double ('d') 类型的值 */ void PushDoubleValue(PluginValue* value, double vl) { if (value != nullptr) { value->values.push_back(PValue().SetDoubleValue(vl)); } }
/** * 设置 char ('c') 类型的值 */ void PushCharValue(PluginValue* value, char vl) { if (value != nullptr) { value->values.push_back(PValue().SetCharValue(vl)); } }
/** * 设置 unsigned long long ('K') 类型的值 */ void PushUnsignedLongLongValue(PluginValue* value, unsigned long long vl) { if (value != nullptr) { value->values.push_back(PValue().SetULongLongValue(vl)); } }
/** * 设置 float ('f') 类型的值 */ void PushFloatValue(PluginValue* value, float vl) { if (value != nullptr) { value->values.push_back(PValue().SetFloatValue(vl)); } }
/** * 设置 unsigned int ('I') 类型的值 */ void PushUnsignedIntValue(PluginValue* value, unsigned int vl) { if (value != nullptr) { value->values.push_back(PValue().SetUIntValue(vl)); } }
/** * 设置 long long ('L') 类型的值 */ void PushLongLongValue(PluginValue* value, long long vl) { if (value != nullptr) { value->values.push_back(PValue().SetLongLongValue(vl)); } }
/** * 设置 int ('i') 类型的值 */ void PushIntValue(PluginValue* value, int vl) { if (value != nullptr) { value->values.push_back(PValue().SetIntValue(vl)); } }
/** * 设置 unsigned short ('H') 类型的值 */ void PushUnsignedShortValue(PluginValue* value, unsigned short vl) { if (value != nullptr) { value->values.push_back(PValue().SetUShortValue(vl)); } }
/** * 设置 short ('h') 类型的值 */ void PushShortValue(PluginValue* value, short vl) { if (value != nullptr) { value->values.push_back(PValue().SetShortValue(vl)); } }
/** * 设置 byte ('B') 类型的值 */ void PushByteValue(PluginValue* value, unsigned char vl) { if (value != nullptr) { value->values.push_back(PValue().SetByteValue(vl)); } }
/** * 设置 bool ('b') 类型的值 */ void PushBoolValue(PluginValue* value, bool vl) { if (value != nullptr) { value->values.push_back(PValue().SetBoolValue(vl)); } }
static void main_loop_serial(struct plan7_s *hmm, const char* seq, int seqLen, struct threshold_s *thresh, int do_forward, int do_null2, int do_xnu, struct histogram_s *histogram, struct tophit_s *ghit, struct tophit_s *dhit, int *ret_nseq, TaskStateInfo& ti) { //get HMMERTaskLocalData HMMERTaskLocalData *tld = getHMMERTaskLocalData(); alphabet_s *al = &tld->al; struct dpmatrix_s *mx; // DP matrix, growable struct p7trace_s *tr; // traceback unsigned char *dsq; // digitized target sequence float sc; // score of an HMM search double pvalue; // pvalue of an HMM score double evalue; // evalue of an HMM score // Create a DP matrix; initially only two rows big, but growable; // we overalloc by 25 rows (L dimension) when we grow; not growable // in model dimension, since we know the hmm size mx = CreatePlan7Matrix(1, hmm->M, 25, 0); assert(seqLen > 0); dsq = DigitizeSequence(seq, seqLen); if (do_xnu && al->Alphabet_type == hmmAMINO) { XNU(dsq, seqLen); } // 1. Recover a trace by Viterbi. // In extreme cases, the alignment may be literally impossible; // in which case, the score comes out ridiculously small (but not // necessarily <= -INFTY, because we're not terribly careful // about underflow issues), and tr will be returned as NULL. if (P7ViterbiSpaceOK(seqLen, hmm->M, mx)) { sc = P7Viterbi(dsq, seqLen, hmm, mx, &tr); } else { sc = P7SmallViterbi(dsq, seqLen, hmm, mx, &tr, ti.progress); } // 2. If we're using Forward scores, calculate the // whole sequence score; this overrides anything // PostprocessSignificantHit() is going to do to the per-seq score. if (do_forward) { sc = P7Forward(dsq, seqLen, hmm, NULL); if (do_null2) sc -= TraceScoreCorrection(hmm, tr, dsq); } // 2. Store score/pvalue for global alignment; will sort on score, // which in hmmsearch is monotonic with E-value. // Keep all domains in a significant sequence hit. // We can only make a lower bound estimate of E-value since // we don't know the final value of nseq yet, so the list // of hits we keep in memory is >= the list we actually // output. // pvalue = PValue(hmm, sc); evalue = thresh->Z ? (double) thresh->Z * pvalue : (double) pvalue; if (sc >= thresh->globT && evalue <= thresh->globE) { sc = PostprocessSignificantHit(ghit, dhit, tr, hmm, dsq, seqLen, (char *)"sequence", //todo: sqinfo.name, NULL, NULL, do_forward, sc, do_null2, thresh, FALSE); // FALSE-> not hmmpfam mode, hmmsearch mode } AddToHistogram(histogram, sc); P7FreeTrace(tr); free(dsq); FreePlan7Matrix(mx); return; }
int main(void) { struct p7trace_s *tr; /* traceback of an alignment */ int master_tid; /* PVM TID of our master */ char *hmmfile; /* file to read HMM(s) from */ HMMFILE *hmmfp; /* opened hmmfile for reading */ struct plan7_s *hmm; char *seq; char *dsq; int len; int nhmm; /* number of HMM to work on */ float sc; int my_idx = -1; /* my index, 0..nslaves-1 */ float globT; /* T parameter: keep only hits > globT bits */ double globE; /* E parameter: keep hits < globE E-value */ double pvalue; /* Z*pvalue = Evalue */ int Z; /* nseq to base E value calculation on */ int send_trace; /* TRUE if score is significant */ int do_xnu; /* TRUE to do XNU filter on seq */ int do_forward; /* TRUE to use Forward() scores not Viterbi */ int do_null2; /* TRUE to correct scores w/ ad hoc null2 */ int alphatype; /* alphabet type, hmmAMINO or hmmNUCLEIC */ int code; /* return code after initialization */ /* 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 to us: * 1) len of HMM file name (int) * 2) name of HMM file (string) * 3) length of sequence string (int) * 4) sequence (string) * 5) globT threshold * 6) globE threshold * 7) Z * 8) do_xnu flag * 9) do_forward flag * 10) do_null2 flag * 11) alphabet type * We receive the broadcast and open the files. ******************************************************************/ master_tid = pvm_parent(); /* who's our master? */ pvm_recv(master_tid, HMMPVM_INIT); pvm_upkint(&len, 1, 1); hmmfile = MallocOrDie(sizeof(char *) * (len+1)); pvm_upkstr(hmmfile); pvm_upkint(&len, 1, 1); seq = MallocOrDie(sizeof(char *) * (len+1)); pvm_upkstr(seq); pvm_upkfloat(&globT, 1, 1); pvm_upkdouble(&globE, 1, 1); pvm_upkint(&Z, 1, 1); pvm_upkint(&do_xnu, 1, 1); pvm_upkint(&do_forward, 1, 1); pvm_upkint(&do_null2, 1, 1); pvm_upkint(&alphatype, 1, 1); SetAlphabet(alphatype); /* Open HMM file (maybe in HMMERDB) */ code = HMMPVM_OK; if ((hmmfp = HMMFileOpen(hmmfile, "HMMERDB")) == NULL) code = HMMPVM_NO_HMMFILE; else if (hmmfp->gsi == NULL) code = HMMPVM_NO_INDEX; /* report our status. */ pvm_initsend(PvmDataDefault); pvm_pkint(&code, 1, 1); pvm_send(master_tid, HMMPVM_RESULTS); dsq = DigitizeSequence(seq, len); if (do_xnu) XNU(dsq, len); /***************************************************************** * Main loop. * Receive an integer 0..nhmm-1 for which HMM to search against. * If we receive a -1, we shut down. *****************************************************************/ for (;;) { pvm_recv(master_tid, HMMPVM_WORK); pvm_upkint(&nhmm, 1, 1); if (my_idx < 0) my_idx = nhmm; /* first time thru, remember what index we are. */ if (nhmm == -1) break; /* shutdown signal */ /* move to our assigned HMM in the HMM file, and read it */ HMMFilePositionByIndex(hmmfp, nhmm); if (! HMMFileRead(hmmfp, &hmm)) Die("unexpected end of HMM file"); if (hmm == NULL) Die("unexpected failure to parse HMM file"); P7Logoddsify(hmm, TRUE); /* Score sequence, do alignment (Viterbi), recover trace */ if (P7ViterbiSize(len, hmm->M) <= RAMLIMIT) { SQD_DPRINTF1(("P7Viterbi(): Estimated size %d Mb\n", P7ViterbiSize(len, hmm->M))); sc = P7Viterbi(dsq, len, hmm, &tr); } else { SQD_DPRINTF1(("P7SmallViterbi() called; %d Mb > %d\n", P7ViterbiSize(len, hmm->M), RAMLIMIT)); sc = P7SmallViterbi(dsq, len, hmm, &tr); } if (do_forward) sc = P7Forward(dsq, len, hmm, NULL); if (do_null2) sc -= TraceScoreCorrection(hmm, tr, dsq); pvalue = PValue(hmm, sc); send_trace = (sc > globT && pvalue * (float) Z < globE) ? 1 : 0; /* return output */ pvm_initsend(PvmDataDefault); pvm_pkint(&my_idx, 1, 1); /* tell master who we are */ pvm_pkstr(hmm->name); /* double check that we did the right thing */ pvm_pkfloat(&sc, 1, 1); pvm_pkdouble(&pvalue, 1, 1); pvm_pkint(&send_trace, 1, 1); /* flag for whether a trace structure is coming */ if (send_trace) PVMPackTrace(tr); pvm_send(master_tid, HMMPVM_RESULTS); /* cleanup */ FreePlan7(hmm); P7FreeTrace(tr); } /*********************************************** * Cleanup, return. ***********************************************/ HMMFileClose(hmmfp); free(seq); free(dsq); free(hmmfile); return 0; }