int main() { read_pars("input"); read_ensemble_pars(base_path,T,ibeta,nmass,mass,iml_un,nlights,data_list_file); TH=L=T/2; init_latpars(); int ncombo=nmass*nmass; //load all the corrs double *buf=new double[4*ncombo*T*(njack+1)]; FILE *fin=open_file(combine("%s/%s",base_path,corr_name).c_str(),"r"); int stat=fread(buf,sizeof(double),4*ncombo*(njack+1)*T,fin); if(stat!=4*ncombo*(njack+1)*T) { cerr<<"Error loading data!"<<endl; exit(1); } jvec M(ncombo,njack); jvec Z2(ncombo,njack); //define minuit staff TMinuit minu(2); minu.SetPrintLevel(-1); minu.SetFCN(chi2); corr_fit=new double[TH+1]; corr_err=new double[TH+1]; //fit each combo int ic=0; for(int ims=0;ims<nmass;ims++) for(int imc=ims;imc<nmass;imc++) { //take into account corr jvec corr1(T,njack),corr2(T,njack),corr; int ic1=0+2*(ims+nmass*(0+2*imc)); int ic2=1+2*(ims+nmass*(1+2*imc)); cout<<ims<<" "<<imc<<" "<<ic1<<" "<<ic2<<endl; corr1.put(buf+ic1*T*(njack+1)); corr2.put(buf+ic2*T*(njack+1)); corr=(corr1+corr2)/2; cout<<corr1[0]<<" "<<corr2[0]<<endl; //choose the index of the fitting interval if(ims>=nlights) ifit_int=2; else if(imc>=nlights) ifit_int=1; else ifit_int=0; //simmetrize corr=corr.simmetrized(parity); int ttmin=tmin[ifit_int]; int ttmax=tmax[ifit_int]; jvec Mcor=effective_mass(corr),Z2cor(TH+1,njack); jack Meff=constant_fit(Mcor,ttmin,ttmax); for(int t=0;t<=TH;t++) for(int ijack=0;ijack<=njack;ijack++) Z2cor[t].data[ijack]=corr[t].data[ijack]/fun_fit(1,Meff[ijack],t); jack Z2eff=constant_fit(Z2cor,ttmin,ttmax); if(!isnan(Z2eff[0])) minu.DefineParameter(0,"Z2",Z2eff[0],Z2eff.err(),0,2*Z2eff[0]); if(!isnan(Meff[0])) minu.DefineParameter(1,"M",Meff[0],Meff.err(),0,2*Meff[0]); for(int t=tmin[ifit_int];t<=tmax[ifit_int];t++) corr_err[t]=corr.data[t].err(); //jacknife analysis for(int ijack=0;ijack<njack+1;ijack++) { //copy data so that glob function may access it for(int t=tmin[ifit_int];t<=tmax[ifit_int];t++) corr_fit[t]=corr.data[t].data[ijack]; //fit double dum; minu.Migrad(); minu.GetParameter(0,Z2.data[ic].data[ijack],dum); minu.GetParameter(1,M.data[ic].data[ijack],dum); } //if((ims==iml_un||ims==nlights-1||ims==nlights||ims==nmass-1)&& //(imc==iml_un||imc==nlights-1||imc==nlights||imc==nmass-1)) { //plot eff mass { ofstream out(combine("eff_mass_plot_%02d_%02d.xmg",ims,imc).c_str()); out<<"@type xydy"<<endl; out<<"@s0 line type 0"<<endl; out<<Mcor<<endl; out<<"&"<<endl; out<<"@type xy"<<endl; double av_mass=M[ic].med(); double er_mass=M[ic].err(); out<<tmin[ifit_int]<<" "<<av_mass-er_mass<<endl; out<<tmax[ifit_int]<<" "<<av_mass-er_mass<<endl; out<<tmax[ifit_int]<<" "<<av_mass+er_mass<<endl; out<<tmin[ifit_int]<<" "<<av_mass+er_mass<<endl; out<<tmin[ifit_int]<<" "<<av_mass-er_mass<<endl; } //plot fun { ofstream out(combine("fun_plot_%02d_%02d.xmg",ims,imc).c_str()); out<<"@type xydy"<<endl; out<<"@s0 line type 0"<<endl; out<<corr<<endl; out<<"&"<<endl; out<<"@type xy"<<endl; for(int t=tmin[ifit_int];t<tmax[ifit_int];t++) out<<t<<" "<<fun_fit(Z2[ic][njack],M[ic][njack],t)<<endl; } } cout<<mass[ims]<<" "<<mass[imc]<<" "<<M[ic]<<" "<<Z2[ic]<<" f:"<<sqrt(Z2[ic])/(sinh(M[ic])*M[ic])*(mass[ims]+mass[imc])<<" fV:"<<Za_med[ibeta]*sqrt(Z2[ic])/M[ic]/lat[ibeta].med()<<endl; ic++; } ofstream out("fitted_mass.xmg"); out<<"@type xydy"<<endl; for(int ims=0;ims<nmass;ims++) { //out<<"s0 line type 0"<<endl; for(int imc=0;imc<nmass;imc++) out<<mass[imc]<<" "<<M[icombo(ims,imc,nmass,nlights,0)]<<endl; out<<"&"<<endl; } M.write_to_binfile(out_file); Z2.append_to_binfile(out_file); return 0; }
static void plot_cross_check(args_t *args) { char *fname; FILE *fp = open_file(&fname, "w", "%s.py", args->plot); fprintf(fp, "import matplotlib as mpl\n" "mpl.use('Agg')\n" "import matplotlib.pyplot as plt\n" "import matplotlib.gridspec as gridspec\n" "import csv\n" "csv.register_dialect('tab', delimiter='\\t', quoting=csv.QUOTE_NONE)\n" "avg = []\n" "dp = []\n" "sm2id = {}\n" "dat = None\n" "min = None\n" "max = None\n" "with open('%s.tab', 'rb') as f:\n" " reader = csv.reader(f, 'tab')\n" " i = 0\n" " for row in reader:\n" " if row[0]=='SM':\n" " sm2id[row[4]] = i\n" " avg.append([i,float(row[1])])\n" " dp.append([i,float(row[2])])\n" " i += 1\n" " elif row[0]=='CN':\n" " val = 0\n" " if int(row[2])!=0: val = float(row[1])/int(row[2])\n" " if not dat:\n" " dat = [[0]*len(sm2id) for x in xrange(len(sm2id))]\n" " min = val\n" " max = val\n" " id_i = sm2id[row[4]]\n" " id_j = sm2id[row[5]]\n" " dat[id_i][id_j] = val\n" " dat[id_j][id_i] = val\n" " if min > val: min = val\n" " if max < val: max = val\n" "\n" "if len(sm2id)<=1: exit(1)\n" "if min==max: exit(1)\n" "\n" "fig = plt.figure(figsize=(6,7))\n" "gs = gridspec.GridSpec(2, 1, height_ratios=[1, 1.5])\n" "ax1 = plt.subplot(gs[0])\n" "ax2 = plt.subplot(gs[1])\n" "\n" "ax1.plot([x[0] for x in avg],[x[1] for x in avg],'^-', ms=3, color='k')\n" "ax3 = ax1.twinx()\n" "ax3.plot([x[0] for x in dp],[x[1] for x in dp],'^-', ms=3, color='r',mec='r')\n" "for tl in ax3.get_yticklabels():\n" " tl.set_color('r')\n" " tl.set_fontsize(9)\n" "\n" "im = ax2.imshow(dat,clim=(min),interpolation='nearest',origin='lower')\n" "cb1 = plt.colorbar(im,ax=ax2)\n" "cb1.set_label('Pairwise discordance')\n" "for t in cb1.ax.get_yticklabels(): t.set_fontsize(9)\n" "\n" "ax1.tick_params(axis='both', which='major', labelsize=9)\n" "ax1.tick_params(axis='both', which='minor', labelsize=9)\n" "ax2.tick_params(axis='both', which='major', labelsize=9)\n" "ax2.tick_params(axis='both', which='minor', labelsize=9)\n" "\n" "ax1.set_title('Sample Discordance Score')\n" "ax2.set_ylabel('Sample ID')\n" "ax2.set_xlabel('Sample ID')\n" "ax3.set_ylabel('Average Depth',color='r')\n" "ax1.set_xlabel('Sample ID')\n" "ax1.set_ylabel('Average discordance')\n" "\n" "plt.subplots_adjust(left=0.15,right=0.87,bottom=0.08,top=0.93,hspace=0.25)\n" "plt.savefig('%s.png')\n" "plt.close()\n" "\n", args->plot,args->plot ); fclose(fp); py_plot(fname); free(fname); }
static void cross_check_gts(args_t *args) { int nsamples = bcf_hdr_nsamples(args->sm_hdr), ndp_arr = 0; unsigned int *dp = (unsigned int*) calloc(nsamples,sizeof(unsigned int)), *ndp = (unsigned int*) calloc(nsamples,sizeof(unsigned int)); // this will overflow one day... int fake_pls = args->no_PLs, ignore_dp = 0; int i,j,k,idx, pl_warned = 0, dp_warned = 0; int32_t *dp_arr = NULL; int *is_hom = args->hom_only ? (int*) malloc(sizeof(int)*nsamples) : NULL; if ( bcf_hdr_id2int(args->sm_hdr, BCF_DT_ID, "PL")<0 ) { if ( bcf_hdr_id2int(args->sm_hdr, BCF_DT_ID, "GT")<0 ) error("[E::%s] Neither PL nor GT present in the header of %s\n", __func__, args->files->readers[0].fname); if ( !args->no_PLs ) fprintf(pysam_stderr,"Warning: PL not present in the header of %s, using GT instead\n", args->files->readers[0].fname); fake_pls = 1; } if ( bcf_hdr_id2int(args->sm_hdr, BCF_DT_ID, "DP")<0 ) ignore_dp = 1; FILE *fp = args->plot ? open_file(NULL, "w", "%s.tab", args->plot) : pysam_stdout; print_header(args, fp); if ( args->all_sites ) fprintf(fp,"# [1]SD, Average Site Discordance\t[2]Chromosome\t[3]Position\t[4]Number of available pairs\t[5]Average discordance\n"); while ( bcf_sr_next_line(args->files) ) { bcf1_t *line = args->files->readers[0].buffer[0]; bcf_unpack(line, BCF_UN_FMT); int npl; if ( !fake_pls ) { npl = bcf_get_format_int32(args->sm_hdr, line, "PL", &args->pl_arr, &args->npl_arr); if ( npl<=0 ) { pl_warned++; continue; } npl /= nsamples; } else npl = fake_PLs(args, args->sm_hdr, line); int mdp = 0; if ( !ignore_dp && (mdp=bcf_get_format_int32(args->sm_hdr, line, "DP", &dp_arr, &ndp_arr)) <= 0 ) dp_warned++; if ( args->hom_only ) { for (i=0; i<nsamples; i++) is_hom[i] = is_hom_most_likely(line->n_allele, args->pl_arr+i*npl); } double sum = 0; int nsum = 0; idx = 0; for (i=0; i<nsamples; i++) { int *ipl = &args->pl_arr[i*npl]; if ( *ipl==-1 ) { idx += i; continue; } // missing genotype if ( mdp>0 && (dp_arr[i]==bcf_int32_missing || !dp_arr[i]) ) { idx += i; continue; } if ( args->hom_only && !is_hom[i] ) { idx += i; continue; } for (j=0; j<i; j++) { int *jpl = &args->pl_arr[j*npl]; if ( *jpl==-1 ) { idx++; continue; } // missing genotype if ( mdp>0 && (dp_arr[j]==bcf_int32_missing || !dp_arr[j]) ) { idx++; continue; } if ( args->hom_only && !is_hom[j] ) { idx++; continue; } int min_pl = INT_MAX; for (k=0; k<npl; k++) { if ( ipl[k]==bcf_int32_missing || jpl[k]==bcf_int32_missing ) break; if ( ipl[k]==bcf_int32_vector_end || jpl[k]==bcf_int32_vector_end ) { k = npl; break; } if ( min_pl > ipl[k]+jpl[k] ) min_pl = ipl[k]+jpl[k]; } if ( k!=npl ) { idx++; continue; } if ( args->all_sites ) { sum += min_pl; nsum++; } args->lks[idx] += min_pl; args->cnts[idx]++; if ( mdp>0 ) { args->dps[idx] += dp_arr[i] < dp_arr[j] ? dp_arr[i] : dp_arr[j]; dp[i] += dp_arr[i]; ndp[i]++; dp[j] += dp_arr[j]; ndp[j]++; } else { args->dps[idx]++; dp[i]++; ndp[i]++; dp[j]++; ndp[j]++; } idx++; } } if ( args->all_sites ) fprintf(fp,"SD\t%s\t%d\t%d\t%.0f\n", args->sm_hdr->id[BCF_DT_CTG][line->rid].key, line->pos+1, nsum, nsum?sum/nsum:0); } if ( dp_arr ) free(dp_arr); if ( args->pl_arr ) free(args->pl_arr); if ( args->tmp_arr ) free(args->tmp_arr); if ( is_hom ) free(is_hom); if ( pl_warned ) fprintf(pysam_stderr, "[W::%s] PL was not found at %d site(s)\n", __func__, pl_warned); if ( dp_warned ) fprintf(pysam_stderr, "[W::%s] DP was not found at %d site(s)\n", __func__, dp_warned); // Output samples sorted by average discordance double *score = (double*) calloc(nsamples,sizeof(double)); args->sites = (double*) calloc(nsamples,sizeof(double)); idx = 0; for (i=0; i<nsamples; i++) { for (j=0; j<i; j++) { score[i] += args->lks[idx]; score[j] += args->lks[idx]; args->sites[i] += args->cnts[idx]; args->sites[j] += args->cnts[idx]; idx++; } } for (i=0; i<nsamples; i++) if ( args->sites[i] ) score[i] /= args->sites[i]; double **p = (double**) malloc(sizeof(double*)*nsamples), avg_score = 0; for (i=0; i<nsamples; i++) p[i] = &score[i]; qsort(p, nsamples, sizeof(int*), cmp_doubleptr); // The average discordance gives the number of differing sites in % with -G1 fprintf(fp, "# [1]SM\t[2]Average Discordance\t[3]Average depth\t[4]Average number of sites\t[5]Sample\t[6]Sample ID\n"); for (i=0; i<nsamples; i++) { idx = p[i] - score; double adp = ndp[idx] ? (double)dp[idx]/ndp[idx] : 0; double nsites = args->sites[idx]/(nsamples-1); avg_score += score[idx]; fprintf(fp, "SM\t%f\t%.2lf\t%.0lf\t%s\t%d\n", score[idx]*100., adp, nsites, args->sm_hdr->samples[idx],i); } // // Overall score: maximum absolute deviation from the average score // fprintf(fp, "# [1] MD\t[2]Maximum deviation\t[3]The culprit\n"); // fprintf(fp, "MD\t%f\t%s\n", (score[idx] - avg_score/nsamples)*100., args->sm_hdr->samples[idx]); // idx still set free(p); free(score); free(dp); free(ndp); // Pairwise discordances fprintf(fp, "# [1]CN\t[2]Discordance\t[3]Number of sites\t[4]Average minimum depth\t[5]Sample i\t[6]Sample j\n"); idx = 0; for (i=0; i<nsamples; i++) { for (j=0; j<i; j++) { fprintf(fp, "CN\t%.0f\t%d\t%.2f\t%s\t%s\n", args->lks[idx], args->cnts[idx], args->cnts[idx]?(double)args->dps[idx]/args->cnts[idx]:0.0, args->sm_hdr->samples[i],args->sm_hdr->samples[j]); idx++; } } fclose(fp); if ( args->plot ) plot_cross_check(args); }
/* Set the options on the Curl handle from a Request object. Takes each field * in the Request object and uses it to set the appropriate option on the Curl * handle. */ static void set_options_from_request(VALUE self, VALUE request) { struct curl_state* state = get_curl_state(self); CURL* curl = state->handle; ID action = Qnil; VALUE headers = Qnil; VALUE url = Qnil; VALUE timeout = Qnil; VALUE redirects = Qnil; VALUE proxy = Qnil; VALUE proxy_type = Qnil; VALUE credentials = Qnil; VALUE ignore_content_length = Qnil; VALUE insecure = Qnil; VALUE cacert = Qnil; VALUE ssl_version = Qnil; VALUE buffer_size = Qnil; VALUE action_name = rb_funcall(request, rb_intern("action"), 0); VALUE a_c_encoding = rb_funcall(request, rb_intern("automatic_content_encoding"), 0); headers = rb_funcall(request, rb_intern("headers"), 0); if (RTEST(headers)) { if (rb_type(headers) != T_HASH) { rb_raise(rb_eArgError, "Headers must be passed in a hash."); } rb_hash_foreach(headers, each_http_header, self); } action = SYM2ID(action_name); if(rb_funcall(request, rb_intern("force_ipv4"), 0)) { curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4); } if (action == rb_intern("get")) { VALUE data = rb_funcall(request, rb_intern("upload_data"), 0); VALUE download_file = rb_funcall(request, rb_intern("file_name"), 0); curl_easy_setopt(curl, CURLOPT_HTTPGET, 1); if (RTEST(data)) { set_request_body(state, data); curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET"); } if (RTEST(download_file)) { state->download_file = open_file(download_file, "wb"); curl_easy_setopt(curl, CURLOPT_WRITEDATA, state->download_file); } else { state->download_file = NULL; } } else if (action == rb_intern("post") || action == rb_intern("put") || action == rb_intern("patch")) { VALUE data = rb_funcall(request, rb_intern("upload_data"), 0); VALUE filename = rb_funcall(request, rb_intern("file_name"), 0); VALUE multipart = rb_funcall(request, rb_intern("multipart"), 0); if (action == rb_intern("post")) { curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST"); } else if (action == rb_intern("put")) { curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT"); } else if (action == rb_intern("patch")) { curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PATCH"); } if (RTEST(data) && !RTEST(multipart)) { if (action == rb_intern("post")) { curl_easy_setopt(curl, CURLOPT_POST, 1); } set_request_body(state, data); } else if (RTEST(filename) && !RTEST(multipart)) { set_chunked_encoding(state); set_request_body_file(state, filename); } else if (RTEST(multipart)) { if (action == rb_intern("post")) { if(RTEST(data) && RTEST(filename)) { if (rb_type(data) == T_HASH && rb_type(filename) == T_HASH) { rb_hash_foreach(data, formadd_values, self); rb_hash_foreach(filename, formadd_files, self); } else { rb_raise(rb_eArgError, "Data and Filename must be passed in a hash."); } } curl_easy_setopt(curl, CURLOPT_HTTPPOST, state->post); } else { rb_raise(rb_eArgError, "Multipart PUT not supported"); } } else { rb_raise(rb_eArgError, "Must provide either data or a filename when doing a PUT or POST"); } // support for data passed with a DELETE request (e.g.: used by elasticsearch) } else if (action == rb_intern("delete")) { VALUE data = rb_funcall(request, rb_intern("upload_data"), 0); if (RTEST(data)) { long len = RSTRING_LEN(data); state->upload_buf = StringValuePtr(data); curl_easy_setopt(curl, CURLOPT_POST, 1); curl_easy_setopt(curl, CURLOPT_POSTFIELDS, state->upload_buf); curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, len); } curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE"); } else if (action == rb_intern("head")) { curl_easy_setopt(curl, CURLOPT_NOBODY, 1); } else { VALUE action_name = rb_funcall(request, rb_intern("action_name"), 0); curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, StringValuePtr(action_name)); } curl_easy_setopt(curl, CURLOPT_HTTPHEADER, state->headers); curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, state->error_buf); // Enable automatic content-encoding support via gzip/deflate if set in the request, // see https://curl.haxx.se/libcurl/c/CURLOPT_ACCEPT_ENCODING.html if(RTEST(a_c_encoding)) { #ifdef CURLOPT_ACCEPT_ENCODING curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, ""); #elif defined CURLOPT_ENCODING curl_easy_setopt(curl, CURLOPT_ENCODING, ""); #else rb_raise(rb_eArgError, "The libcurl version installed doesn't support automatic content negotiation"); #endif } url = rb_funcall(request, rb_intern("url"), 0); if (!RTEST(url)) { rb_raise(rb_eArgError, "Must provide a URL"); } curl_easy_setopt(curl, CURLOPT_URL, StringValuePtr(url)); #ifdef CURLPROTO_HTTP // Security: do not allow Curl to go looking on gopher/SMTP etc. // Must prevent situations like this: // https://hackerone.com/reports/115748 curl_easy_setopt(curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS); curl_easy_setopt(curl, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS); #endif timeout = rb_funcall(request, rb_intern("timeout"), 0); if (RTEST(timeout)) { curl_easy_setopt(curl, CURLOPT_TIMEOUT, FIX2INT(timeout)); } timeout = rb_funcall(request, rb_intern("connect_timeout"), 0); if (RTEST(timeout)) { curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, FIX2INT(timeout)); } redirects = rb_funcall(request, rb_intern("max_redirects"), 0); if (RTEST(redirects)) { int r = FIX2INT(redirects); curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, r == 0 ? 0 : 1); curl_easy_setopt(curl, CURLOPT_MAXREDIRS, r); } proxy = rb_funcall(request, rb_intern("proxy"), 0); if (RTEST(proxy)) { curl_easy_setopt(curl, CURLOPT_PROXY, StringValuePtr(proxy)); } proxy_type = rb_funcall(request, rb_intern("proxy_type"), 0); if (RTEST(proxy_type)) { curl_easy_setopt(curl, CURLOPT_PROXYTYPE, NUM2LONG(proxy_type)); } credentials = rb_funcall(request, rb_intern("credentials"), 0); if (RTEST(credentials)) { VALUE auth_type = rb_funcall(request, rb_intern("auth_type"), 0); curl_easy_setopt(curl, CURLOPT_HTTPAUTH, NUM2LONG(auth_type)); curl_easy_setopt(curl, CURLOPT_USERPWD, StringValuePtr(credentials)); } ignore_content_length = rb_funcall(request, rb_intern("ignore_content_length"), 0); if (RTEST(ignore_content_length)) { curl_easy_setopt(curl, CURLOPT_IGNORE_CONTENT_LENGTH, 1); } insecure = rb_funcall(request, rb_intern("insecure"), 0); if(RTEST(insecure)) { curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0); curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0); } ssl_version = rb_funcall(request, rb_intern("ssl_version"), 0); if(RTEST(ssl_version)) { VALUE ssl_version_str = rb_funcall(ssl_version, rb_intern("to_s"), 0); char* version = StringValuePtr(ssl_version_str); if(strcmp(version, "SSLv2") == 0) { curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_SSLv2); } else if(strcmp(version, "SSLv3") == 0) { curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_SSLv3); } else if(strcmp(version, "TLSv1") == 0) { curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1); } else { rb_raise(eUnsupportedSSLVersion, "Unsupported SSL version: %s", version); } } cacert = rb_funcall(request, rb_intern("cacert"), 0); if(RTEST(cacert)) { curl_easy_setopt(curl, CURLOPT_CAINFO, StringValuePtr(cacert)); } buffer_size = rb_funcall(request, rb_intern("buffer_size"), 0); if (RTEST(buffer_size)) { curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, NUM2LONG(buffer_size)); } if(state->debug_file) { curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); curl_easy_setopt(curl, CURLOPT_STDERR, state->debug_file); } }
static int read_config_file(const char *name) { idFile * fp; char *w[MAXWORDS], *cp; ToneBank *bank=0; int i, j, k, line=0, words; static int rcf_count=0; if (rcf_count>50) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "Probable source loop in configuration files"); return (-1); } if (!(fp=open_file(name, 1, OF_VERBOSE))) return -2; char tokTmp[1024]; while ( Gets( *fp, tokTmp, 1024 ) ) { line++; w[words=0]=strtok(tokTmp, " \t\r\n\240"); if (!w[0] || (*w[0]=='#')) continue; while (w[words] && (words < MAXWORDS)) w[++words]=strtok(0," \t\r\n\240"); if (!strcmp(w[0], "dir")) { if (words < 2) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: No directory given\n", name, line); return -3; } for (i=1; i<words; i++) add_to_pathlist(w[i]); } else if (!strcmp(w[0], "source")) { if (words < 2) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: No file name given\n", name, line); return -4; } for (i=1; i<words; i++) { rcf_count++; read_config_file(w[i]); rcf_count--; } } else if (!strcmp(w[0], "default")) { if (words != 2) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: Must specify exactly one patch name\n", name, line); return -5; } strncpy(def_instr_name, w[1], 255); def_instr_name[255]='\0'; } else if (!strcmp(w[0], "drumset")) { if (words < 2) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: No drum set number given\n", name, line); return -6; } i=atoi(w[1]); if (i<0 || i>127) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: Drum set must be between 0 and 127\n", name, line); return -7; } if (!drumset[i]) { drumset[i]=(ToneBank*)safe_malloc(sizeof(ToneBank)); memset(drumset[i], 0, sizeof(ToneBank)); } bank=drumset[i]; } else if (!strcmp(w[0], "bank")) { if (words < 2) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: No bank number given\n", name, line); return -8; } i=atoi(w[1]); if (i<0 || i>127) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: Tone bank must be between 0 and 127\n", name, line); return -9; } if (!tonebank[i]) { tonebank[i]=(ToneBank*)safe_malloc(sizeof(ToneBank)); memset(tonebank[i], 0, sizeof(ToneBank)); } bank=tonebank[i]; } else { if ((words < 2) || (*w[0] < '0' || *w[0] > '9')) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: syntax error\n", name, line); return -10; } i=atoi(w[0]); if (i<0 || i>127) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: Program must be between 0 and 127\n", name, line); return -11; } if (!bank) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: Must specify tone bank or drum set " "before assignment\n", name, line); return -12; } if (bank->tone[i].name) Real_Tim_Free(bank->tone[i].name); strcpy((bank->tone[i].name=(char*)safe_malloc(strlen(w[1])+1)),w[1]); bank->tone[i].note=bank->tone[i].amp=bank->tone[i].pan= bank->tone[i].strip_loop=bank->tone[i].strip_envelope= bank->tone[i].strip_tail=-1; for (j=2; j<words; j++) { if (!(cp=strchr(w[j], '='))) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: bad patch option %s\n", name, line, w[j]); return -13; } *cp++=0; if (!strcmp(w[j], "amp")) { k=atoi(cp); if ((k<0 || k>MAX_AMPLIFICATION) || (*cp < '0' || *cp > '9')) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: amplification must be between " "0 and %d\n", name, line, MAX_AMPLIFICATION); return -14; } bank->tone[i].amp=k; } else if (!strcmp(w[j], "note")) { k=atoi(cp); if ((k<0 || k>127) || (*cp < '0' || *cp > '9')) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: note must be between 0 and 127\n", name, line); return -15; } bank->tone[i].note=k; } else if (!strcmp(w[j], "pan")) { if (!strcmp(cp, "center")) k=64; else if (!strcmp(cp, "left")) k=0; else if (!strcmp(cp, "right")) k=127; else k=((atoi(cp)+100) * 100) / 157; if ((k<0 || k>127) || (k==0 && *cp!='-' && (*cp < '0' || *cp > '9'))) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: panning must be left, right, " "center, or between -100 and 100\n", name, line); return -16; } bank->tone[i].pan=k; } else if (!strcmp(w[j], "keep")) { if (!strcmp(cp, "env")) bank->tone[i].strip_envelope=0; else if (!strcmp(cp, "loop")) bank->tone[i].strip_loop=0; else { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: keep must be env or loop\n", name, line); return -17; } } else if (!strcmp(w[j], "strip")) { if (!strcmp(cp, "env")) bank->tone[i].strip_envelope=1; else if (!strcmp(cp, "loop")) bank->tone[i].strip_loop=1; else if (!strcmp(cp, "tail")) bank->tone[i].strip_tail=1; else { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: strip must be env, loop, or tail\n", name, line); return -18; } } else { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: line %d: bad patch option %s\n", name, line, w[j]); return -19; } } } } if ( fp == 0 ) //(ferror(fp)) { ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "Can't read from %s\n", name); close_file(fp); return -20; } close_file(fp); return 0; }
// a = length of struct bu array // i = position to restore from static int restore_manifest(struct bu *arr, int a, int i, const char *tmppath1, const char *tmppath2, regex_t *regex, int srestore, enum action act, const char *client, char **dir_for_notify, struct cntr *p1cntr, struct cntr *cntr, struct config *cconf) { int ret=0; gzFile zp=NULL; char *manifest=NULL; char *datadir=NULL; FILE *logfp=NULL; char *logpath=NULL; char *logpathz=NULL; // For sending status information up to the server. char status=STATUS_RESTORING; if(act==ACTION_RESTORE) status=STATUS_RESTORING; else if(act==ACTION_VERIFY) status=STATUS_VERIFYING; if( (act==ACTION_RESTORE && !(logpath=prepend_s(arr[i].path, "restorelog", strlen("restorelog")))) || (act==ACTION_RESTORE && !(logpathz=prepend_s(arr[i].path, "restorelog.gz", strlen("restorelog.gz")))) || (act==ACTION_VERIFY && !(logpath=prepend_s(arr[i].path, "verifylog", strlen("verifylog")))) || (act==ACTION_VERIFY && !(logpathz=prepend_s(arr[i].path, "verifylog.gz", strlen("verifylog.gz")))) || !(manifest=prepend_s(arr[i].path, "manifest.gz", strlen("manifest.gz")))) { log_and_send_oom(__FUNCTION__); ret=-1; } else if(!(logfp=open_file(logpath, "ab")) || set_logfp(logfp, cconf)) { char msg[256]=""; snprintf(msg, sizeof(msg), "could not open log file: %s", logpath); log_and_send(msg); ret=-1; } *dir_for_notify=strdup(arr[i].path); log_restore_settings(cconf, srestore); // First, do a pass through the manifest to set up the counters. // This is the equivalent of a phase1 scan during backup. if(!ret && !(zp=gzopen_file(manifest, "rb"))) { log_and_send("could not open manifest"); ret=-1; } else { int ars=0; int quit=0; struct sbuf sb; init_sbuf(&sb); while(!quit) { if((ars=sbuf_fill(NULL, zp, &sb, cntr))) { if(ars<0) ret=-1; // ars==1 means end ok quit++; } else { if((!srestore || check_srestore(cconf, sb.path)) && check_regex(regex, sb.path)) { do_filecounter(p1cntr, sb.cmd, 0); if(sb.endfile) do_filecounter_bytes(p1cntr, strtoull(sb.endfile, NULL, 10)); /* if(sb.cmd==CMD_FILE || sb.cmd==CMD_ENC_FILE || sb.cmd==CMD_METADATA || sb.cmd==CMD_ENC_METADATA || sb.cmd==CMD_VSS || sb.cmd==CMD_ENC_VSS || sb.cmd==CMD_VSS_T || sb.cmd==CMD_ENC_VSS_T || sb.cmd==CMD_EFS_FILE) do_filecounter_bytes(p1cntr, (unsigned long long) sb.statp.st_size); */ } } free_sbuf(&sb); } free_sbuf(&sb); gzclose_fp(&zp); } if(cconf->send_client_counters) { if(send_counters(client, p1cntr, cntr)) { ret=-1; } } // Now, do the actual restore. if(!ret && !(zp=gzopen_file(manifest, "rb"))) { log_and_send("could not open manifest"); ret=-1; } else { char cmd; int s=0; int quit=0; size_t len=0; struct sbuf sb; // For out-of-sequence directory restoring so that the // timestamps come out right: int scount=0; struct sbuf **sblist=NULL; init_sbuf(&sb); while(!quit) { int ars=0; char *buf=NULL; if(async_read_quick(&cmd, &buf, &len)) { logp("read quick error\n"); ret=-1; quit++; break; } if(buf) { //logp("got read quick\n"); if(cmd==CMD_WARNING) { logp("WARNING: %s\n", buf); do_filecounter(cntr, cmd, 0); free(buf); buf=NULL; continue; } else if(cmd==CMD_INTERRUPT) { // Client wanted to interrupt the // sending of a file. But if we are // here, we have already moved on. // Ignore. free(buf); buf=NULL; continue; } else { logp("unexpected cmd from client: %c:%s\n", cmd, buf); free(buf); buf=NULL; ret=-1; quit++; break; } } if((ars=sbuf_fill(NULL, zp, &sb, cntr))) { if(ars<0) ret=-1; // ars==1 means end ok quit++; } else { if((!srestore || check_srestore(cconf, sb.path)) && check_regex(regex, sb.path) && restore_ent(client, &sb, &sblist, &scount, arr, a, i, tmppath1, tmppath2, act, status, cconf, cntr, p1cntr)) { ret=-1; quit++; } } free_sbuf(&sb); } gzclose_fp(&zp); // Restore any directories that are left in the list. if(!ret) for(s=scount-1; s>=0; s--) { if(restore_sbuf(sblist[s], arr, a, i, tmppath1, tmppath2, act, client, status, p1cntr, cntr, cconf)) { ret=-1; break; } } free_sbufs(sblist, scount); if(!ret) ret=do_restore_end(act, cntr); //print_endcounter(cntr); print_filecounters(p1cntr, cntr, act); reset_filecounter(p1cntr, time(NULL)); reset_filecounter(cntr, time(NULL)); } set_logfp(NULL, cconf); compress_file(logpath, logpathz, cconf); if(manifest) free(manifest); if(datadir) free(datadir); if(logpath) free(logpath); if(logpathz) free(logpathz); return ret; }
static int flash_image(libmtd_t libmtd, const struct mtd_dev_info *mtd, const struct ubigen_info *ui, struct ubi_scan_info *si) { int fd, img_ebs, eb, written_ebs = 0, divisor, skip_data_read = 0; off_t st_size; fd = open_file(&st_size); if (fd < 0) return fd; img_ebs = st_size / mtd->eb_size; if (img_ebs > si->good_cnt) { sys_errmsg("file \"%s\" is too large (%lld bytes)", args.image, (long long)st_size); goto out_close; } if (st_size % mtd->eb_size) { return sys_errmsg("file \"%s\" (size %lld bytes) is not multiple of ""eraseblock size (%d bytes)", args.image, (long long)st_size, mtd->eb_size); goto out_close; } verbose(args.verbose, "will write %d eraseblocks", img_ebs); divisor = img_ebs; for (eb = 0; eb < mtd->eb_cnt; eb++) { int err, new_len; char buf[mtd->eb_size]; long long ec; if (!args.quiet && !args.verbose) { printf("\r" PROGRAM_NAME ": flashing eraseblock %d -- %2lld %% complete ", eb, (long long)(eb + 1) * 100 / divisor); fflush(stdout); } if (si->ec[eb] == EB_BAD) { divisor += 1; continue; } if (args.verbose) { normsg_cont("eraseblock %d: erase", eb); fflush(stdout); } err = mtd_erase(libmtd, mtd, args.node_fd, eb); if (err) { if (!args.quiet) printf("\n"); sys_errmsg("failed to erase eraseblock %d", eb); if (errno != EIO) goto out_close; if (mark_bad(mtd, si, eb)) goto out_close; continue; } if (!skip_data_read) { err = read_all(fd, buf, mtd->eb_size); if (err) { sys_errmsg("failed to read eraseblock %d from \"%s\"", written_ebs, args.image); goto out_close; } } skip_data_read = 0; if (args.override_ec) ec = args.ec; else if (si->ec[eb] <= EC_MAX) ec = si->ec[eb] + 1; else ec = si->mean_ec; if (args.verbose) { printf(", change EC to %lld", ec); fflush(stdout); } err = change_ech((struct ubi_ec_hdr *)buf, ui->image_seq, ec); if (err) { errmsg("bad EC header at eraseblock %d of \"%s\"", written_ebs, args.image); goto out_close; } if (args.verbose) { printf(", write data\n"); fflush(stdout); } new_len = drop_ffs(mtd, buf, mtd->eb_size); err = mtd_write(libmtd, mtd, args.node_fd, eb, 0, buf, new_len, NULL, 0, 0); if (err) { sys_errmsg("cannot write eraseblock %d", eb); if (errno != EIO) goto out_close; err = mtd_torture(libmtd, mtd, args.node_fd, eb); if (err) { if (mark_bad(mtd, si, eb)) goto out_close; } /* * We have to make sure that we do not read next block * of data from the input image or stdin - we have to * write buf first instead. */ skip_data_read = 1; continue; } if (++written_ebs >= img_ebs) break; } if (!args.quiet && !args.verbose) printf("\n"); close(fd); return eb + 1; out_close: close(fd); return -1; }
/************************************************************************* * Entry point for ama *************************************************************************/ int main(int argc, char *argv[]) { int max_seq_length = MAX_SEQ; STRING_LIST_T* selected_motifs = NULL; double pseudocount = 0.01; int output_format = CISML_FORMAT; program_name = "ama"; int scoring = AVG_ODDS; BOOLEAN_T pvalues = FALSE; BOOLEAN_T normalize_scores = FALSE; BOOLEAN_T combine_duplicates = FALSE; int num_gc_bins = 1; int sdbg_order = -1; // don't use sequence background BOOLEAN_T scan_both_strands = TRUE; ARRAY_T* pos_bg_freqs = NULL; ARRAY_T* rev_bg_freqs = NULL; clock_t c0, c1; /* measuring cpu_time */ CISML_T *cisml; char * out_dir = NULL; BOOLEAN_T clobber = FALSE; int i; int last = 0; ALPH_T alph = INVALID_ALPH; /********************************************** * COMMAND LINE PROCESSING **********************************************/ const int num_options = 16; cmdoption const motif_scan_options[] = { { "max-seq-length", REQUIRED_VALUE }, { "motif", REQUIRED_VALUE }, { "motif-pseudo", REQUIRED_VALUE }, { "rma", NO_VALUE }, { "pvalues", NO_VALUE }, { "sdbg", REQUIRED_VALUE }, { "norc", NO_VALUE }, { "cs", NO_VALUE }, { "o-format", REQUIRED_VALUE }, { "o", REQUIRED_VALUE }, { "oc", REQUIRED_VALUE }, { "scoring", REQUIRED_VALUE }, { "verbosity", REQUIRED_VALUE }, { "gcbins", REQUIRED_VALUE }, { "last", REQUIRED_VALUE }, { "version", NO_VALUE } }; int option_index = 0; // Define the usage message. char usage[] = "USAGE: ama [options] <motif file> <sequence file> [<background file>]\n" "\n" " Options:\n" " --sdbg <order>\t\t\tUse Markov background model of\n" " \t\t\t\t\torder <order> derived from the sequence\n" " \t\t\t\t\tto compute its likelihood ratios.\n" " \t\t\t\t\tOverrides --pvalues, --gcbins and --rma;\n" " \t\t\t\t\t<background file> is required unless\n" " \t\t\t\t\t--sdbg is given.\n" " --motif <id>\t\t\tUse only the motif identified by <id>.\n" " \t\t\t\t\tThis option may be repeated.\n" " --motif-pseudo <float>\t\tThe value <float> times the background\n" " \t\t\t\t\tfrequency is added to the count of each\n" " \t\t\t\t\tletter when creating the likelihood \n" " \t\t\t\t\tratio matrix (default: %g).\n" " --norc\t\t\t\tDisables the scanning of the reverse\n" " \t\t\t\t\tcomplement strand.\n" " --scoring [avg-odds|max-odds]\tIndicates whether the average or \n" " \t\t\t\t\tthe maximum odds should be calculated\n" " \t\t\t\t\t(default: avg-odds)\n" " --rma\t\t\t\tScale motif scores to the range 0-1.\n" " \t\t\t\t\t(Relative Motif Affinity).\n" " \t\t\t\t\tMotif scores are scaled by the maximum\n" " \t\t\t\t\tscore achievable by that PWM. (default:\n" " \t\t\t\t\tmotif scores are not normalized)\n" " --pvalues\t\t\t\tPrint p-value of avg-odds score in cisml\n" " \t\t\t\t\toutput. Ignored for max-odds scoring.\n" " \t\t\t\t\t(default: p-values are not printed)\n" " --gcbins <bins>\t\t\tCompensate p-values for GC content of\n" " \t\t\t\t\teach sequence using given number of \n" " \t\t\t\t\tGC range bins. Recommended bins: 41.\n" " \t\t\t\t\t(default: p-values are based on\n" " \t\t\t\t\tfrequencies in background file)\n" " --cs\t\t\t\tEnable combining sequences with same\n" " \t\t\t\t\tidentifier by taking the average score\n" " \t\t\t\t\tand the Sidac corrected p-value.\n" " --o-format [gff|cisml]\t\tOutput file format (default: cisml)\n" " \t\t\t\t\tignored if --o or --oc option used\n" " --o <directory>\t\t\tOutput all available formats to\n" " \t\t\t\t\t<directory>; give up if <directory>\n" " \t\t\t\t\texists\n" " --oc <directory>\t\t\tOutput all available formats to\n" " \t\t\t\t\t<directory>; if <directory> exists\n" " \t\t\t\t\toverwrite contents\n" " --verbosity [1|2|3|4]\t\tControls amount of screen output\n" " \t\t\t\t\t(default: %d)\n" " --max-seq-length <int>\t\tSet the maximum length allowed for \n" " \t\t\t\t\tinput sequences. (default: %d)\n" " --last <int>\t\t\tUse only scores of (up to) last <n>\n" " \t\t\t\t\tsequence positions to compute AMA.\n" " --version \t\t\tPrint version and exit.\n" "\n"; // Parse the command line. if (simple_setopt(argc, argv, num_options, motif_scan_options) != NO_ERROR) { die("Error processing command line options: option name too long.\n"); } BOOLEAN_T setoutputformat = FALSE; BOOLEAN_T setoutputdirectory = FALSE; while (TRUE) { int c = 0; char* option_name = NULL; char* option_value = NULL; const char * message = NULL; // Read the next option, and break if we're done. c = simple_getopt(&option_name, &option_value, &option_index); if (c == 0) { break; } else if (c < 0) { (void) simple_getopterror(&message); die("Error processing command line options (%s).\n", message); } else if (strcmp(option_name, "max-seq-length") == 0) { max_seq_length = atoi(option_value); } else if (strcmp(option_name, "norc") == 0) { scan_both_strands = FALSE; } else if (strcmp(option_name, "cs") == 0) { combine_duplicates = TRUE; } else if (strcmp(option_name, "motif") == 0) { if (selected_motifs == NULL) { selected_motifs = new_string_list(); } add_string(option_value, selected_motifs); } else if (strcmp(option_name, "motif-pseudo") == 0) { pseudocount = atof(option_value); } else if (strcmp(option_name, "o-format") == 0) { if (setoutputdirectory) { if (verbosity >= NORMAL_VERBOSE) fprintf(stderr, "output directory specified, ignoring --o-format\n"); } else { setoutputformat = TRUE; if (strcmp(option_value, "gff") == 0) output_format = GFF_FORMAT; else if (strcmp(option_value, "cisml") == 0) output_format = CISML_FORMAT; else { if (verbosity >= NORMAL_VERBOSE) fprintf(stderr, "Output format not known. Using standard instead (cisML).\n"); output_format = CISML_FORMAT; } } } else if (strcmp(option_name, "o") == 0 || strcmp(option_name, "oc") == 0) { setoutputdirectory = TRUE; if (setoutputformat) { if (verbosity >= NORMAL_VERBOSE) fprintf(stderr, "output directory specified, ignoring --o-format\n"); } clobber = strcmp(option_name, "oc") == 0; out_dir = (char*) malloc (sizeof(char)*(strlen(option_value)+1)); strcpy(out_dir, option_value); output_format = DIRECTORY_FORMAT; } else if (strcmp(option_name, "verbosity") == 0) { verbosity = atoi(option_value); } else if (strcmp(option_name, "scoring") == 0) { if (strcmp(option_value, "max-odds") == 0) scoring = MAX_ODDS; else if (strcmp(option_value, "avg-odds") == 0) scoring = AVG_ODDS; else if (strcmp(option_value, "sum-odds") == 0) scoring = SUM_ODDS; else die("Specified scoring scheme not known.\n", message); } else if (strcmp(option_name, "pvalues") == 0) { pvalues = TRUE; } else if (strcmp(option_name, "rma") == 0) { normalize_scores = TRUE; fprintf(stderr, "Normalizing motif scores using RMA method.\n"); } else if (strcmp(option_name, "gcbins") == 0) { num_gc_bins = atoi(option_value); pvalues = TRUE; if (num_gc_bins <= 1) die("Number of bins in --gcbins must be greater than 1.\n", message); } else if (strcmp(option_name, "sdbg") == 0) { sdbg_order = atoi(option_value); // >=0 means use sequence bkg } else if (strcmp(option_name, "last") == 0) { int i = 0; if (option_value[0] == '-') ++i; while (option_value[i] != '\0') { if (!isdigit(option_value[i])) { die("Specified parameter 'last' contains non-numeric characters.\n"); } ++i; } last = atoi(option_value); if (errno != 0) { die("Specified parameter 'last' could not be parsed as a number as:\n%s\n",strerror(errno)); } if (last < 0) { die("Specified parameter 'last' had negative value (%d) when only postive or zero values are allowed \n", last); } } else if (strcmp(option_name, "version") == 0) { fprintf(stdout, VERSION "\n"); exit(EXIT_SUCCESS); } } // --sdbg overrides --pvalues and --gcbins and --rma int req_args = 3; if (sdbg_order >= 0) { pvalues = FALSE; normalize_scores = FALSE; num_gc_bins = 1; req_args = 2; } // Check all required arguments given if (sdbg_order >= 0 && argc > option_index + req_args) { die("<background file> cannot be given together with --sdbg.\n"); } else if (argc != option_index + req_args) { fprintf(stderr, usage, pseudocount, verbosity, max_seq_length); exit(EXIT_FAILURE); } // Get required arguments. char* motif_filename = argv[option_index]; option_index++; char* fasta_filename = argv[option_index]; option_index++; char* bg_filename; if (req_args == 3) { // required unless --sdbg given bg_filename = argv[option_index]; option_index++; } else { bg_filename = "--uniform--"; // So PSSMs will use uniform background; // we can multiply them out later. } // measure time c0 = clock(); // Set up hash tables for computing reverse complement if doing --sdbg if (sdbg_order >= 0) setup_hash_alph(DNAB); // Create cisml data structure for recording results cisml = allocate_cisml(program_name, motif_filename, fasta_filename); set_cisml_background_file(cisml, bg_filename); /********************************************** * Read the motifs and background model. **********************************************/ int num_motifs = 0; MREAD_T *mread; ARRAYLST_T *motifs; PSSM_PAIR_T** pssm_pairs; // note pssm_pairs is an array of pointers //this reads any meme file, xml, txt and html mread = mread_create(motif_filename, OPEN_MFILE); mread_set_bg_source(mread, bg_filename); mread_set_pseudocount(mread, pseudocount); motifs = mread_load(mread, NULL); alph = mread_get_alphabet(mread); pos_bg_freqs = mread_get_background(mread); mread_destroy(mread); num_motifs = arraylst_size(motifs); // allocate memory for PSSM pairs pssm_pairs = (PSSM_PAIR_T**)mm_malloc(sizeof(PSSM_PAIR_T*) * num_motifs); if (verbosity >= NORMAL_VERBOSE) fprintf(stderr, "Number of motifs in file %d.\n", num_motifs); // make a CISML pattern to hold scores for each motif PATTERN_T** patterns = NULL; Resize(patterns, num_motifs, PATTERN_T*); int motif_index; for (motif_index = 0; motif_index < num_motifs; motif_index++) { MOTIF_T* motif = (MOTIF_T*)arraylst_get(motif_index, motifs); patterns[motif_index] = allocate_pattern(get_motif_id(motif), ""); add_cisml_pattern(cisml, patterns[motif_index]); } // make reverse complement motifs and background frequencies. if (scan_both_strands == TRUE) { add_reverse_complements(motifs); assert(arraylst_size(motifs) == (2 * num_motifs)); rev_bg_freqs = allocate_array(get_array_length(pos_bg_freqs)); complement_dna_freqs(pos_bg_freqs, rev_bg_freqs); } /************************************************************** * Convert motif matrices into log-odds matrices. * Scale them. * Compute the lookup tables for the PDF of scaled log-odds scores. **************************************************************/ int ns = scan_both_strands ? 2 : 1; // number of strands for (motif_index = 0; motif_index < num_motifs; motif_index++) { MOTIF_T *motif, *motif_rc; motif = (MOTIF_T*)arraylst_get(motif_index*ns, motifs); if (scan_both_strands) motif_rc = (MOTIF_T*)arraylst_get(motif_index*ns + 1, motifs); else motif_rc = NULL; /* * Note: If scanning both strands, we complement the motif frequencies * but not the background frequencies so the motif looks the same. * However, the given frequencies are used in computing the p-values * since they represent the frequencies on the negative strands. * (If we instead were to complement the input sequence, keeping the * the motif fixed, we would need to use the complemented frequencies * in computing the p-values. Is that any clearer?) */ double range = 300; // 100 is not very good; 1000 is great but too slow PSSM_T* pos_pssm = build_motif_pssm( motif, pos_bg_freqs, pos_bg_freqs, NULL, // Priors not used 0.0L, // alpha not used range, num_gc_bins, TRUE ); PSSM_T* neg_pssm = (scan_both_strands ? build_motif_pssm( motif_rc, rev_bg_freqs, pos_bg_freqs, NULL, // Priors not used 0.0L, // alpha not used range, num_gc_bins, TRUE ) : NULL ); pssm_pairs[motif_index] = create_pssm_pair(pos_pssm, neg_pssm); } // Open the FASTA file for reading. FILE* fasta_file = NULL; if (open_file(fasta_filename, "r", FALSE, "FASTA", "sequences", &fasta_file) == 0) { die("Couldn't open the file %s.\n", fasta_filename); } if (verbosity >= NORMAL_VERBOSE) { if (last == 0) { fprintf(stderr, "Using entire sequence\n"); } else { fprintf(stderr, "Limiting sequence to last %d positions.\n", last); } } /************************************************************** * Read in all sequences and score with all motifs **************************************************************/ int seq_loading_num = 0; // keeps track on the number of sequences read in total int seq_counter = 0; // holds the index to the seq in the pattern int unique_seqs = 0; // keeps track on the number of unique sequences BOOLEAN_T need_postprocessing = FALSE; SEQ_T* sequence = NULL; RBTREE_T* seq_ids = rbtree_create(rbtree_strcasecmp,NULL,free,rbtree_intcpy,free); RBNODE_T* seq_node; BOOLEAN_T created; while (read_one_fasta(alph, fasta_file, max_seq_length, &sequence)) { ++seq_loading_num; created = FALSE; char* seq_name = get_seq_name(sequence); int seq_len = get_seq_length(sequence); int scan_len; if (last != 0) { scan_len = last; } else { scan_len = seq_len; } // red-black trees are only required if duplicates should be combined if (combine_duplicates){ //lookup seq id and create new entry if required, return sequence index char *tmp_id = mm_malloc(strlen(seq_name)+1); // required copy for rb-tree strncpy(tmp_id,seq_name,strlen(seq_name)+1); seq_node = rbtree_lookup(seq_ids, tmp_id, TRUE, &created); if (created) {// assign it a loading number rbtree_set(seq_ids, seq_node, &unique_seqs); seq_counter = unique_seqs; ++unique_seqs; } else { seq_counter = *((int*)rbnode_get(seq_node)); } } // // Set up sequence-dependent background model and compute // log cumulative probability of sequence. // double *logcumback = NULL; // array of log cumulative probs. if (sdbg_order >= 0) { Resize(logcumback, seq_len+1, double); char* raw_seq = get_raw_sequence(sequence); BOOLEAN rc = FALSE; double *a_cp = get_markov_from_sequence(raw_seq, alph_string(alph), rc, sdbg_order, 0); log_cum_back(raw_seq, a_cp, sdbg_order, logcumback); myfree(a_cp); } // Get the GC content of the sequence if binning p-values by GC // and store it in the sequence object. if (num_gc_bins > 1) { ARRAY_T *freqs = get_sequence_freqs(sequence, alph); set_total_gc_sequence(sequence, get_array_item(1,freqs) + get_array_item(2,freqs)); // f(C) + f(G) free_array(freqs); // clean up } else { set_total_gc_sequence(sequence, -1); // flag ignore } /************************************************************** * Process all motifs. **************************************************************/ int ns = scan_both_strands ? 2 : 1; for (motif_index = 0; motif_index < num_motifs; motif_index++) { PATTERN_T *pattern = patterns[motif_index]; MOTIF_T* motif = (MOTIF_T*)arraylst_get(ns*motif_index, motifs); char* motif_id = (scan_both_strands ? get_motif_st_id(motif) : get_motif_id(motif)); if (verbosity >= HIGH_VERBOSE) { fprintf(stderr, "Using motif %s of width %d.\n", motif_id, get_motif_length(motif)); } if ((selected_motifs == NULL) || (have_string(get_motif_id(motif), selected_motifs) == TRUE)) { if (verbosity >= HIGHER_VERBOSE) { fprintf(stderr, "Scanning %s sequence with length %d " "abbreviated to %d with motif %s with length %d.\n", seq_name, seq_len, scan_len, motif_id, get_motif_length(motif)); } SCANNED_SEQUENCE_T* scanned_seq = NULL; if (!combine_duplicates || get_pattern_num_scanned_sequences(pattern) <= seq_counter){ // Create a scanned_sequence record and save it in the pattern. scanned_seq = allocate_scanned_sequence(seq_name, seq_name, pattern); set_scanned_sequence_length(scanned_seq, scan_len); } else { // get existing sequence record scanned_seq = get_pattern_scanned_sequences(pattern)[seq_counter]; set_scanned_sequence_length(scanned_seq, max(scan_len, get_scanned_sequence_length(scanned_seq))); } // check if scanned component of sequence has sufficient length for the motif if (scan_len < get_motif_length(motif)) { // set score to zero and p-value to 1 if not set yet if(!has_scanned_sequence_score(scanned_seq)){ set_scanned_sequence_score(scanned_seq, 0.0); } if(pvalues && !has_scanned_sequence_pvalue(scanned_seq)){ set_scanned_sequence_pvalue(scanned_seq, 1.0); } add_scanned_sequence_scanned_position(scanned_seq); if (get_scanned_sequence_num_scanned_positions(scanned_seq) > 0L) need_postprocessing = TRUE; if (verbosity >= HIGH_VERBOSE) fprintf(stderr, "%s too short for motif %s. Score set to 0!\n", seq_name, motif_id); } else { // scan the sequence using average/maximum motif affinity ama_sequence_scan(alph, sequence, logcumback, pssm_pairs[motif_index], scoring, pvalues, last, scanned_seq, &need_postprocessing); } } else { if (verbosity >= HIGH_VERBOSE) fprintf(stderr, "Skipping motif %s.\n", motif_id); } } // All motifs parsed free_seq(sequence); if (sdbg_order >= 0) myfree(logcumback); } // read sequences
/** * Expects a file like: **/ void read_data_events(char *mmaped_file) { /** Header **/ FILE *data = open_file(mmaped_file); if(!data) { printf("#Warning: data file %s not found\n", mmaped_file); return; } if(!data_events) data_events = pqueue_init(10, cmp_pri, get_pri, set_pri, get_pos, set_pos); rbtree metadata = rbtree_create(); char line[512]; struct data_ev *event; int nb_lines = 0; uint64_t type; while(fgets(line, sizeof(line), data)) { nb_lines++; event = malloc(sizeof(*event)); if(sscanf(line, "%lu %lu %lu %lu %d %u", &event->rdt, &event->malloc.begin, &event->malloc.end, &type, &event->cpu, &event->tid) != 6) { goto test_info; } if(type == 0) { // free event->type = FREE; } else if(type == 2) { // munmap event->type = FREE; //munmap is not handled correctly yet => fake free } else { // malloc / mmap event->type = MALLOC; event->malloc.end = event->malloc.begin + event->malloc.end; if(type == 1) { char * val = rbtree_lookup(metadata, (void*)event->rdt, pointer_cmp); if(val) event->malloc.info = val; else asprintf(&event->malloc.info, "datasize%lu-%d", event->malloc.end - event->malloc.begin, nb_lines); } else { /*#define MAP_SHARED 0x01 #define MAP_PRIVATE 0x02*/ if(event->malloc.end - event->malloc.begin == 8392704) { /* All stacks seem to be of that size */ asprintf(&event->malloc.info, "thread-stack-%d", nb_lines); } else if(type & 0x01) { asprintf(&event->malloc.info, "mmap-shared%lu-%d", event->malloc.end - event->malloc.begin, nb_lines); } else if(type & 0x02) { asprintf(&event->malloc.info, "mmap-priv%lu-%d", event->malloc.end - event->malloc.begin, nb_lines); } else { asprintf(&event->malloc.info, "mmap-??%lu-%d", event->malloc.end - event->malloc.begin, nb_lines); } } } pqueue_insert(data_events, event); total_data_samples++; continue; test_info:; uint64_t time, loc; int read; if(sscanf(line, "#%lu 0x%lx %n\n", &time, &loc, &read) != 2) { //printf("fail %s %d\n", line, read); goto fail; } char *met_value = strdup(line + read); int met_len = strlen(met_value)-1; if(met_len < 5) // malloc probably not correctly resolved asprintf(&met_value, "%lu", time); else met_value[met_len] = '\0'; rbtree_insert(metadata, (void*)time, met_value, pointer_cmp); fail: //printf("#Unrecognized line: %s", line); free(event); continue; } if(!active_data) active_data = rbtree_create(); if(verbose) printf("#All data events added successfully ; now processing samples\n"); }
/** * including: centroid [ K * d], member [K * ...], */ void Clustering::cluster_into_file(const char *folder){ char filename[255] = {'\0'}; FILE *fp; int nci, di, i; /// centroid sprintf(filename, "%s/%s", folder, FileCentroid); fp = open_file(filename, "w"); for(nci = 0; nci < ncenter; nci++) { fprintf(fp, "%d", d); // d for(di = 0; di < d; di++) { // centroids fprintf(fp, " %f", centroid[nci*d+di]); } fputc('\n', fp); } fclose(fp); /// member sprintf(filename, "%s/%s", folder, FileMember); fp = open_file(filename, "w"); for(nci = 0; nci < ncenter; nci++) { fprintf(fp, "%d", member[nci].size()); // member amount for(i = 0; i < member[nci].size(); i++) // member ids { // centroids fprintf(fp, " %d", member[nci][i]); } fputc('\n', fp); } fclose(fp); /// assign sprintf(filename, "%s/%s", folder, FileAssign); fp = open_file(filename, "w"); for(i = 0; i < n; i++) { fprintf(fp, "%d\n", assign[i]); } fclose(fp); /* nassign, etc. left to update /// store all clusters [binary format] for(nci = 0; nci < ncenter; nci++) { // the nci-th cluster memset(filename, 0, 255); sprintf(filename, "%s/%d%s", folder, nci, CLUSTER_POXFIX); fp = open_file(filename, "wb"); for(i = 0; i < nassign[nci]; i++) { fwrite(&member[nci][i], sizeof(int), 1, fp); // dimension fwrite(ds->data+d*member[nci][i],sizeof(float), d, fp); // data } fclose(fp); } /// store all clusters [text format] for(nci = 0; nci < ncenter; nci++) { // the nci-th cluster memset(filename, 0, 255); sprintf(filename, "%s/%d.txt", folder, nci); fp = open_file(filename, "w"); for(i = 0; i < nassign[nci]; i++) { fprintf(fp, "%d %d", i, member[nci][i]); for(di = 0; di < d; di++){ fprintf(fp, " %f", ds->data[d*member[nci][i]+di]); } fputc('\n', fp); } fclose(fp); } */ }
static int store_file_load(void(*receive_msg)(Msg*)) { List *keys; Octstr *store_file, *key; Msg *msg; int retval, msgs; long end, pos; if (filename == NULL) return 0; mutex_lock(file_mutex); if (file != NULL) { fclose(file); file = NULL; } store_file = octstr_read_file(octstr_get_cstr(filename)); if (store_file != NULL) info(0, "Loading store file `%s'", octstr_get_cstr(filename)); else { store_file = octstr_read_file(octstr_get_cstr(newfile)); if (store_file != NULL) info(0, "Loading store file `%s'", octstr_get_cstr(newfile)); else { store_file = octstr_read_file(octstr_get_cstr(bakfile)); if (store_file != NULL) info(0, "Loading store file `%s'", octstr_get_cstr(bakfile)); else { info(0, "Cannot open any store file, starting a new one"); retval = open_file(filename); goto end; } } } info(0, "Store-file size %ld, starting to unpack%s", octstr_len(store_file), octstr_len(store_file) > 10000 ? " (may take awhile)" : ""); pos = 0; msgs = 0; end = octstr_len(store_file); while (pos < end) { if (read_msg(&msg, store_file, &pos) == -1) { error(0, "Garbage at store-file, skipped."); continue; } if (msg_type(msg) == sms) { store_to_dict(msg); msgs++; } else if (msg_type(msg) == ack) { store_to_dict(msg); } else { warning(0, "Strange message in store-file, discarded, " "dump follows:"); msg_dump(msg, 0); } msg_destroy(msg); } octstr_destroy(store_file); info(0, "Retrieved %d messages, non-acknowledged messages: %ld", msgs, dict_key_count(sms_dict)); /* now create a new sms_store out of messages left */ keys = dict_keys(sms_dict); while ((key = gwlist_extract_first(keys)) != NULL) { msg = dict_remove(sms_dict, key); if (store_to_dict(msg) != -1) { receive_msg(msg); } else { error(0, "Found unknown message type in store file."); msg_dump(msg, 0); msg_destroy(msg); } octstr_destroy(key); } gwlist_destroy(keys, octstr_destroy_item); /* Finally, generate new store file out of left messages */ retval = do_dump(); end: mutex_unlock(file_mutex); /* allow using of store */ gwlist_remove_producer(loaded); /* start dumper thread */ if ((cleanup_thread = gwthread_create(store_dumper, NULL))==-1) panic(0, "Failed to create a cleanup thread!"); return retval; }
void input_flight_info_from_file(int id, char file_name[], char server_host[], int server_port) { //int year, month, day, hour, minute, second; //double millisecond; double latitude, longitude, altitude; double roll = 0.0 , pitch= 0.0, yaw = 0.0; char buffer[BUFSIZE*sizeof(char)]; FILE *fp = open_file(file_name, "r"); int valid_buffer_start = 0; int valid_buffer_end = fread(buffer, sizeof(char), BUFSIZE, fp); while(valid_buffer_start < valid_buffer_end){ bool has_line = false; int line_size = 0; while(!has_line){ if(valid_buffer_start == valid_buffer_end){ int count = fread(buffer + line_size, sizeof(char), BUFSIZE - line_size, fp); if(count > 0){ valid_buffer_start = line_size; valid_buffer_end = line_size + count; }else{ buffer[valid_buffer_start] = '\n'; } } if(line_size + 2 < BUFSIZE){ buffer[line_size] = buffer[valid_buffer_start++]; if (buffer[line_size] == '#'){ buffer[line_size] = '\0'; }else if (buffer[line_size] == '\n' || buffer[line_size] == '\r'){ buffer[line_size] = '\0'; has_line = true; } }else{ fprintf(stderr, "error: line overflow.\n"); exit(EXIT_FAILURE); } line_size++; } //while(count) int count = sscanf(buffer, "%lf,%lf,%lf ", &latitude, &longitude, &altitude); //if </coordinates> if (count == 3){ Time_stamp time_stamp = new_time_stamp(2008, 01, 01, 00, 01, 00, 00.0); //Time_stamp time_stamp = new_time_stamp(year, month, day, hour, minute, second, millisecond); Position position = new_position(longitude, latitude, feet_to_metres(altitude)); print_position(position); Orientation orientation = new_orientation(roll, pitch, yaw); id = 1; Flight_info flight_info = new_flight_info(id, time_stamp, position, orientation); if (!give_flight_info_to_server(flight_info, server_host, server_port)){ fprintf(stderr, "Give flight info to server failed\n"); } }else if (count > 0){ fprintf(stderr, "Found a sad line in input, parsed %d elements\n", count); } } }
/************************************************************************** write_reaction_output: In: the output_set we want to write to disk the flag that signals an end to the scheduled reaction outputs Out: 0 on success, 1 on failure. The reaction output buffer is flushed and written to disk. Indices are not reset; that's the job of the calling function. **************************************************************************/ int write_reaction_output(struct volume *world, struct output_set *set) { FILE *fp; struct output_column *column; char *mode; u_int n_output; u_int i; switch (set->file_flags) { case FILE_OVERWRITE: case FILE_CREATE: if (set->chunk_count == 0) mode = "w"; else mode = "a"; break; case FILE_SUBSTITUTE: if (world->chkpt_seq_num == 1 && set->chunk_count == 0) mode = "w"; else mode = "a"; break; case FILE_APPEND: case FILE_APPEND_HEADER: mode = "a"; break; default: mcell_internal_error( "Bad file output code %d for reaction data output file '%s'.", set->file_flags, set->outfile_name); } fp = open_file(set->outfile_name, mode); if (fp == NULL) return 1; /*int idx = set->block->buf_index;*/ if (set->column_head->buffer[0].data_type != COUNT_TRIG_STRUCT) { n_output = set->block->buffersize; if (set->block->buf_index < set->block->buffersize) n_output = set->block->buf_index; if (world->notify->file_writes == NOTIFY_FULL) mcell_log("Writing %d lines to output file %s.", n_output, set->outfile_name); /* Write headers */ if (set->chunk_count == 0 && set->header_comment != NULL && set->file_flags != FILE_APPEND && (world->chkpt_seq_num == 1 || set->file_flags == FILE_APPEND_HEADER || set->file_flags == FILE_CREATE || set->file_flags == FILE_OVERWRITE)) { if (set->block->timer_type == OUTPUT_BY_ITERATION_LIST) fprintf(fp, "%sIteration_#", set->header_comment); else fprintf(fp, "%sSeconds", set->header_comment); for (column = set->column_head; column != NULL; column = column->next) { if (column->expr->title == NULL) fprintf(fp, " untitled"); else fprintf(fp, " %s", column->expr->title); } fprintf(fp, "\n"); } /* Write data */ for (i = 0; i < n_output; i++) { fprintf(fp, "%.15g", set->block->time_array[i]); for (column = set->column_head; column != NULL; column = column->next) { switch (column->buffer[i].data_type) { case COUNT_INT: fprintf(fp, " %d", (column->buffer[i].val.ival)); break; case COUNT_DBL: fprintf(fp, " %.9g", (column->buffer[i].val.dval)); break; case COUNT_UNSET: fprintf(fp, " X"); break; case COUNT_TRIG_STRUCT: default: if (column->expr->title != NULL) mcell_warn( "Unexpected data type in column titled '%s' -- skipping.", column->expr->title); else mcell_warn("Unexpected data type in untitled column -- skipping."); break; } } fprintf(fp, "\n"); } } else /* Write accumulated trigger data */ { struct output_trigger_data *trig; char event_time_string[1024]; /* Wouldn't run out of space even if we printed out DBL_MAX in non-exponential notation! */ n_output = (u_int)set->column_head->initial_value; for (i = 0; i < n_output; i++) { trig = set->column_head->buffer[i].val.tval; if (set->exact_time_flag) sprintf(event_time_string, "%.12g ", trig->event_time); else strcpy(event_time_string, ""); if (trig->flags & TRIG_IS_RXN) /* Just need time, pos, name */ { fprintf(fp, "%.15g %s%.9g %.9g %.9g %s\n", trig->t_iteration, event_time_string, trig->loc.x, trig->loc.y, trig->loc.z, (trig->name == NULL) ? "" : trig->name); } else if (trig->flags & TRIG_IS_HIT) /* Need orientation also */ { fprintf(fp, "%.15g %s%.9g %.9g %.9g %d %s\n", trig->t_iteration, event_time_string, trig->loc.x, trig->loc.y, trig->loc.z, trig->orient, (trig->name == NULL) ? "" : trig->name); } else /* Molecule count -- need both number and orientation */ { fprintf(fp, "%.15g %s%.9g %.9g %.9g %d %d %s %lu\n", trig->t_iteration, event_time_string, trig->loc.x, trig->loc.y, trig->loc.z, trig->orient, trig->how_many, (trig->name == NULL) ? "" : trig->name, trig->id); } } } set->chunk_count++; fclose(fp); return 0; }
static void on_open_selected_file(GtkMenuItem *menuitem, gpointer user_data) { GeanyDocument *doc = document_get_current(); gchar *sel = NULL; gchar *filename = NULL; gchar *path = NULL; g_return_if_fail(doc != NULL); sel = get_selection(); if (!sel) return; setptr(sel, utils_get_locale_from_utf8(sel)); if (g_path_is_absolute(sel)) { filename = g_strdup(sel); if (!g_file_test(filename, G_FILE_TEST_EXISTS)) { g_free(filename); filename = NULL; } } if (!filename) { if (doc->file_name) { path = g_path_get_dirname(doc->file_name); setptr(path, utils_get_locale_from_utf8(path)); } if (!path) path = g_get_current_dir(); filename = g_build_path(G_DIR_SEPARATOR_S, path, sel, NULL); if (!g_file_test(filename, G_FILE_TEST_EXISTS)) { g_free(filename); filename = NULL; } g_free(path); } if (!filename && geany_data->app->project != NULL) { gchar **pathv; gint i; path = g_strdup(""); pathv = g_strsplit_set(sel, "/\\", -1); for (i = g_strv_length(pathv) - 1; i >= 0; i--) { if (g_strcmp0(pathv[i], "..") == 0) break; setptr(path, g_build_filename(G_DIR_SEPARATOR_S, pathv[i], path, NULL)); } g_strfreev(pathv); if (g_strcmp0(path, "") != 0) { FindData data; data.subpath = path; data.found_path = NULL; g_hash_table_foreach(g_prj->file_tag_table, (GHFunc)find_name, &data); if (data.found_path) { filename = g_strdup(data.found_path); setptr(filename, utils_get_locale_from_utf8(filename)); if (!g_file_test(filename, G_FILE_TEST_EXISTS)) { g_free(filename); filename = NULL; } } } g_free(path); } #ifdef G_OS_UNIX if (!filename) { filename = g_build_path(G_DIR_SEPARATOR_S, "/usr/local/include", sel, NULL); if (!g_file_test(filename, G_FILE_TEST_EXISTS)) { g_free(filename); filename = NULL; } } if (!filename) { filename = g_build_path(G_DIR_SEPARATOR_S, "/usr/include", sel, NULL); if (!g_file_test(filename, G_FILE_TEST_EXISTS)) { g_free(filename); filename = NULL; } } #endif if (filename) open_file(filename); g_free(filename); g_free(sel); }
int main (int argc, char* argv[]) { clock_t begin, end; double time_spent; //^^^^^^^^^^^^^^^^^^^^^^^^^ //Default part BEGIN //^^^^^^^^^^^^^^^^^^^^^^^^^ CHECK_DEFAULT_ARGS(); char inName[NAME_MAX] = {}, outName[NAME_MAX] = {}; switch (argc) { case 3: strcpy (inName, argv[1]); strcpy (outName, argv[2]); break; case 2: strcpy (inName, argv[1]); strcpy (outName, "info.csv"); break; default: WRITE_WRONG_USE(); } Buffer words = {}; buffer_construct(&words, inName); char *word = words.chars; #define LISTS(HASH_TYPE) \ ListHead lists_ ## HASH_TYPE [HASH_TABLE_SIZE];\ for (int i = 0; i < HASH_TABLE_SIZE; i++)\ list_head_construct(lists_ ## HASH_TYPE + i); LISTS(xor); //LISTS(const); //LISTS(length); //LISTS(char); //LISTS(sum); int counter = 0, total = words.length; #ifndef NO_OUTPUT printf ("Progress:\n"); #endif // NO_OUTPUT begin = clock(); while (*word) { #ifndef NO_OUTPUT if (counter % (int)total / 1000) printf ("\r%3.1f%%", 100.0*counter/total); #endif // NO_OUTPUT counter++; // Locating first letter if (!isalnum (*word)) word++; else { //Pointer to the word char *new_word = word; // Finding first non-letter while (isalnum (*word) || strchr(OK_PUNCT, *word)) { word++; counter++; } //Indicating the end *word = '\0'; size_t position; #define HASH_ADD(HASH_TYPE) \ position = hash_ ## HASH_TYPE(new_word) % HASH_TABLE_SIZE;\ list_head_add(&lists_ ## HASH_TYPE[position], new_word); HASH_ADD(xor); //HASH_ADD(const); //HASH_ADD(length); //HASH_ADD(char); //HASH_ADD(sum); word++; } } end = clock(); time_spent = (double)(end - begin) / CLOCKS_PER_SEC; printf ("Hash table creation: %lfms\n", time_spent*1000); buffer_destruct(&words); #ifndef NO_OUTPUT open_file (out, outName, "w", "#Output error"); fprintf (out, "Hash value, "); for (int i = 0; i < HASH_TABLE_SIZE; i++) fprintf (out, "%d, ", i); fprintf (out, "\n"); #define PRINT_INFO(HASH_TYPE) \ fprintf (out, "Hash type: " #HASH_TYPE ", ");\ for (int i = 0; i < HASH_TABLE_SIZE; i++)\ fprintf (out, "%lu, ", lists_ ## HASH_TYPE[i].amount);\ fprintf (out, "\n"); PRINT_INFO(xor); //PRINT_INFO(const); //PRINT_INFO(length); //PRINT_INFO(char); //PRINT_INFO(sum); close_file(out); #endif // NO_OUTPUT printf ("\nThe info has been successfully written to %s.\n", outName); list_head_destruct(lists_xor); //list_head_destruct(lists_const); //list_head_destruct(lists_length); //list_head_destruct(lists_char); //list_head_destruct(lists_sum); return NO_ERROR; }
void ANC::lowerbound_crosspoint(DoubleIndex *lb, const float *query){ int i, j, nci, otheri, ineighbor, id_n; float max_dis, temp_dis, sdis_q_c, sdis_q_nc; float *center = fvec_new(d); float *ocenter = fvec_new(d); DoubleIndex *sqdis_query_centroid; // square distance between query and all centroids /// prepare the query centroid square distances sqdis_query_centroid = (DoubleIndex*)malloc(sizeof(DoubleIndex)*ncenter); for(nci = 0; nci < ncenter; nci++) { sqdis_query_centroid[nci].id = nci; memcpy(center, centroid+nci*d, sizeof(float)*d); sqdis_query_centroid[nci].val = odistance_square(query, center, d); } /// figure out lower bounds for each cluster for(nci = 0; nci < ncenter; nci++){ int cnt = 0; sdis_q_c = sqdis_query_centroid[nci].val; // square dis between (q and C) memcpy(center, centroid+nci*d, sizeof(float)*d); // centroid of C max_dis = FLOAT_ZERO; for(i = 0; i < neighbor[nci].size(); i++){ // all neighbor clusters id_n = neighbor[nci][i]; sdis_q_nc = sqdis_query_centroid[id_n].val; // square dis between (q and neighbor cluster) if(f_bigger(sdis_q_c, sdis_q_nc)){ // separating hyperplane cnt += 1; memcpy(ocenter, centroid+id_n*d, sizeof(float)*d); // centroid of the neighbor cluster temp_dis = crosspoint_distance(query, center, ocenter, d, sqrt(sdis_q_c)); if(f_bigger(temp_dis, max_dis)) {// a larger lower bound distance max_dis = temp_dis; } } } lb[nci].id = nci; lb[nci].val = max_dis; } /// sort lower bounds DI_MergeSort(lb, 0, ncenter-1); /// ### store into files FILE *fp = open_file("lowerbound.txt", "w+"); for(i = 0; i < ncenter; i++){ fprintf(fp, " %d-%f", lb[i].id, lb[i].val); } fputc('\n', fp); fclose(fp); free(center); center = NULL; free(ocenter); ocenter = NULL; free(sqdis_query_centroid); sqdis_query_centroid = NULL; }
static int verify_file(const char *fname, int patches, const char *best, const char *datapth, unsigned long long *bytes, const char *endfile, char cmd, int compression, struct cntr *cntr) { MD5_CTX md5; size_t b=0; const char *cp=NULL; const char *newsum=NULL; unsigned char in[ZCHUNK]; unsigned char checksum[MD5_DIGEST_LENGTH+1]; unsigned long long cbytes=0; if(!(cp=strrchr(endfile, ':'))) { logw(cntr, "%s has no md5sum!\n", datapth); return 0; } cp++; if(!MD5_Init(&md5)) { logp("MD5_Init() failed\n"); return -1; } if(patches || cmd==CMD_ENC_FILE || cmd==CMD_ENC_METADATA || cmd==CMD_EFS_FILE || cmd==CMD_ENC_VSS || (!patches && !dpth_is_compressed(compression, best))) { // If we did some patches or encryption, or the compression // was turned off, the resulting file is not gzipped. FILE *fp=NULL; if(!(fp=open_file(best, "rb"))) { logw(cntr, "could not open %s\n", best); return 0; } while((b=fread(in, 1, ZCHUNK, fp))>0) { cbytes+=b; if(!MD5_Update(&md5, in, b)) { logp("MD5_Update() failed\n"); close_fp(&fp); return -1; } } if(!feof(fp)) { logw(cntr, "error while reading %s\n", best); close_fp(&fp); return 0; } close_fp(&fp); } else { gzFile zp=NULL; if(!(zp=gzopen_file(best, "rb"))) { logw(cntr, "could not gzopen %s\n", best); return 0; } while((b=gzread(zp, in, ZCHUNK))>0) { cbytes+=b; if(!MD5_Update(&md5, in, b)) { logp("MD5_Update() failed\n"); gzclose_fp(&zp); return -1; } } if(!gzeof(zp)) { logw(cntr, "error while gzreading %s\n", best); gzclose_fp(&zp); return 0; } gzclose_fp(&zp); } if(!MD5_Final(checksum, &md5)) { logp("MD5_Final() failed\n"); return -1; } newsum=get_checksum_str(checksum); if(strcmp(newsum, cp)) { logp("%s %s\n", newsum, cp); logw(cntr, "md5sum for '%s (%s)' did not match!\n", fname, datapth); logp("md5sum for '%s (%s)' did not match!\n", fname, datapth); return 0; } *bytes+=cbytes; // Just send the file name to the client, so that it can show counters. if(async_write(cmd, fname, strlen(fname))) return -1; return 0; }
/*! \brief Save session data. \details Session data is saved to the session file. \return Returns dmz::True if the session data is successfully saved. \sa dmz::Application::load_session() */ dmz::Boolean dmz::Application::save_session () { Boolean result (False); Config session; _state.rt.get_session_config (session); Config prevDirConfig; const String DefaultDir (_state.appState.get_default_directory ()); if (DefaultDir) { if (session.lookup_config (ApplicationName, prevDirConfig)) { prevDirConfig.store_attribute (DirName, DefaultDir); } else if (DefaultDir != get_home_directory ()) { Config dirConfig (ApplicationName); dirConfig.store_attribute (DirName, DefaultDir); session.add_config (dirConfig); } } if (!session.is_empty () && _state.sessionDir && _state.sessionPath) { if (create_directory (_state.sessionDir)) { FILE *file = open_file (_state.sessionPath, "wb"); if (file) { StreamFile fs (file); write_xml_header (fs); format_config_to_xml (session, fs); close_file (file); file = 0; result = True; if (!_state.quiet) { _state.log.info << "Saved session to file: " << _state.sessionPath << endl; } } else { _state.log.error << "Unable to create session file: " << _state.sessionPath << endl; } } else { _state.log.error << "Unable to create session directory: " << _state.sessionDir << endl; } } else if (session.is_empty ()) { if (!_state.quiet) { _state.log.info << "No session data to save." << endl; } } else if (!_state.sessionDir) { _state.log.error << "Session directory not found." << endl; } else if (!_state.sessionPath) { _state.log.error << "Session file not found." << endl; } return result; }
static int inflate_or_link_oldfile(const char *oldpath, const char *infpath, int compression) { int ret=0; struct stat statp; if(lstat(oldpath, &statp)) { logp("could not lstat %s\n", oldpath); return -1; } if(dpth_is_compressed(compression, oldpath)) { FILE *source=NULL; FILE *dest=NULL; //logp("inflating...\n"); if(!(dest=open_file(infpath, "wb"))) { close_fp(&dest); return -1; } if(!statp.st_size) { // Empty file - cannot inflate. // just close the destination and we have duplicated a // zero length file. logp("asked to inflate zero length file: %s\n", oldpath); close_fp(&dest); return 0; } if(!(source=open_file(oldpath, "rb"))) { close_fp(&dest); return -1; } if((ret=zlib_inflate(source, dest))!=Z_OK) logp("zlib_inflate returned: %d\n", ret); close_fp(&source); if(close_fp(&dest)) { logp("error closing %s in inflate_or_link_oldfile\n", dest); return -1; } } else { // Not compressed - just hard link it. if(link(oldpath, infpath)) { logp("hardlink %s to %s failed: %s\n", infpath, oldpath, strerror(errno)); ret=-1; } } return ret; }
static YAP_Bool compute_prob(void) /* this is the function that implements the compute_prob predicate used in pp.pl */ { YAP_Term out,arg1,arg2,arg3,arg4; variables vars; expr expression; DdNode * function; DdManager * mgr; int nBVar,i,intBits,create_dot; FILE * file; DdNode * array[1]; double prob; char * onames[1]; char inames[1000][20]; char * names[1000]; tablerow * nodes; arg1=YAP_ARG1; arg2=YAP_ARG2; arg3=YAP_ARG3; arg4=YAP_ARG4; mgr=Cudd_Init(0,0,CUDD_UNIQUE_SLOTS,CUDD_CACHE_SLOTS,0); create_dot=YAP_IntOfTerm(arg4); vars=createVars(arg1,mgr,create_dot,inames); //Cudd_PrintInfo(mgr,stderr); /* automatic variable reordering, default method CUDD_REORDER_SIFT used */ //printf("status %d\n",Cudd_ReorderingStatus(mgr,&order)); //printf("order %d\n",order); Cudd_AutodynEnable(mgr,CUDD_REORDER_SAME); /* Cudd_AutodynEnable(mgr, CUDD_REORDER_RANDOM_PIVOT); printf("status %d\n",Cudd_ReorderingStatus(mgr,&order)); printf("order %d\n",order); printf("%d",CUDD_REORDER_RANDOM_PIVOT); */ expression=createExpression(arg2); function=retFunction(mgr,expression,vars); /* the BDD build by retFunction is converted to an ADD (algebraic decision diagram) because it is easier to interpret and to print */ //add=Cudd_BddToAdd(mgr,function); //Cudd_PrintInfo(mgr,stderr); if (create_dot) /* if specified by the user, a dot file for the BDD is written to cpl.dot */ { nBVar=vars.nBVar; for(i=0;i<nBVar;i++) names[i]=inames[i]; array[0]=function; onames[0]="Out"; file = open_file("cpl.dot", "w"); Cudd_DumpDot(mgr,1,array,names,onames,file); fclose(file); } nodes=init_table(vars.nBVar); intBits=sizeof(unsigned int)*8; prob=Prob(function,vars,nodes); out=YAP_MkFloatTerm(prob); destroy_table(nodes,vars.nBVar); Cudd_Quit(mgr); for(i=0;i<vars.nVar;i++) { free(vars.varar[i].probabilities); free(vars.varar[i].booleanVars); } free(vars.varar); free(vars.bVar2mVar); for(i=0;i<expression.nTerms;i++) { free(expression.terms[i].factors); } free(expression.terms); return(YAP_Unify(out,arg3)); }
/** * @brief 复制obj文件数据,只复制v部分和只含点信息的f * @param 空 * @return 非零代表复制成功,0代表复制失败 */ bool ObjModify::copyData() { if(!firstVerticesLine) { if(!getInfo()) { return false; } } string filePathName = inputPath + "\\" + filename; cout << filePathName << endl; ifstream infile; open_file(infile, filePathName.c_str()); string newFilename = outputPath + "\\" + getName() + fileSuffix; ofstream outfile(newFilename.c_str(), ofstream::out);//如果没有对应文件,在根目录下创建一个 for(int i = 0; !infile && i != 10; ++i) { open_file(infile, filePathName.c_str()); } if(!infile) { cerr << "Try 10 times, but still can not open input file: " << filePathName << endl; return false; } if(!outfile) { cerr << "Can not open output file: " << newFilename << endl; return false; } ///写入obj文件头 setHeader(outfile); string line; for(int i = 0; i != firstVerticesLine - 1; ++i) { getline(infile, line); //cout << line << endl; } int v_count = 1, v_percent = 0; int r_count = 1, r_percent = 0; while(getline(infile, line)) { if(line[0] == 'v' && line[1] == ' ') { outfile << line << endl; //显示已处理百分比 if((v_count++ * 10 / vertices) != v_percent) { cout << "vertices processing " << 10 * v_percent << "%" << endl; v_percent = v_count * 10 / vertices; } } else if(line[0] == 'f' && line[1] == ' ') { string fstr; fstr = cov_f(line); outfile << fstr << endl; //显示已处理百分比 if((r_count++ * 10 / triangles ) != r_percent) { cout << "triangles processing " << 10 * r_percent << "%" << endl; r_percent = r_count * 10 / triangles; } } } outfile.close(); infile.close(); return true; }
static int flash_image(const struct mtd_info *mtd, const struct ubigen_info *ui, struct ubi_scan_info *si) { int fd, img_ebs, eb, written_ebs = 0, divisor; off_t st_size; fd = open_file(mtd, si, &st_size); if (fd < 0) return fd; img_ebs = st_size / mtd->eb_size; if (img_ebs > si->good_cnt) { sys_errmsg("file \"%s\" is too large (%lld bytes)", args.image, (long long)st_size); goto out_close; } if (st_size % mtd->eb_size) { return sys_errmsg("file \"%s\" (size %lld bytes) is not multiple of eraseblock size (%d bytes)", args.image, (long long)st_size, mtd->eb_size); goto out_close; } verbose(args.verbose, "will write %d eraseblocks", img_ebs); divisor = img_ebs; for (eb = 0; eb < mtd->eb_cnt; eb++) { int err, new_len; char buf[mtd->eb_size]; long long ec; if (!args.quiet && !args.verbose) { printf("\r" PROGRAM_NAME ": flashing eraseblock %d -- %2lld %% complete ", eb, (long long)(eb + 1) * 100 / divisor); fflush(stdout); } if (si->ec[eb] == EB_BAD) { divisor += 1; continue; } if (args.verbose) { normsg_cont("eraseblock %d: erase", eb); fflush(stdout); } err = mtd_erase(mtd, eb); if (err) { sys_errmsg("failed to erase eraseblock %d", eb); goto out_close; } err = read_all(fd, buf, mtd->eb_size); if (err) { sys_errmsg("failed to read eraseblock %d from \"%s\"", written_ebs, args.image); goto out_close; } if (si->ec[eb] <= EC_MAX) ec = si->ec[eb] + 1; else if (!args.override_ec) ec = si->mean_ec; else ec = args.ec; if (args.verbose) { printf(", change EC to %lld", ec); fflush(stdout); } err = change_ec((struct ubi_ec_hdr *)buf, ec); if (err) { errmsg("bad EC header at eraseblock %d of \"%s\"", written_ebs, args.image); goto out_close; } if (args.verbose) { printf(", write data\n"); fflush(stdout); } new_len = drop_ffs(mtd, buf, mtd->eb_size); err = mtd_write(mtd, eb, 0, buf, new_len); if (err) { sys_errmsg("cannot write eraseblock %d", eb); goto out_close; } if (++written_ebs >= img_ebs) break; } if (!args.quiet && !args.verbose) printf("\n"); close(fd); return eb + 1; out_close: close(fd); return -1; }
/* * Do the actual output. Take a va_list so that we can be called from * multiple different places, even functions that took "..." as input * arguments. */ static int output(int output_id, const char *format, va_list arglist) { int rc = PMIX_SUCCESS; char *str, *out = NULL; output_desc_t *ldi; /* Setup */ if (!initialized) { pmix_output_init(); } /* If it's valid, used, and enabled, output */ if (output_id >= 0 && output_id < PMIX_OUTPUT_MAX_STREAMS && info[output_id].ldi_used && info[output_id].ldi_enabled) { ldi = &info[output_id]; /* Make the strings */ if (PMIX_SUCCESS != (rc = make_string(&str, ldi, format, arglist))) { return rc; } /* Syslog output -- does not use the newline-appended string */ #if defined(HAVE_SYSLOG) if (ldi->ldi_syslog) { syslog(ldi->ldi_syslog_priority, "%s", str); } #endif /* All others (stdout, stderr, file) use temp_str, potentially with a newline appended */ out = temp_str; /* stdout output */ if (ldi->ldi_stdout) { write(fileno(stdout), out, (int)strlen(out)); fflush(stdout); } /* stderr output */ if (ldi->ldi_stderr) { write((-1 == default_stderr_fd) ? fileno(stderr) : default_stderr_fd, out, (int)strlen(out)); fflush(stderr); } /* File output -- first check to see if the file opening was * delayed. If so, try to open it. If we failed to open it, * then just discard (there are big warnings in the * pmix_output.h docs about this!). */ if (ldi->ldi_file) { if (ldi->ldi_fd == -1) { if (PMIX_SUCCESS != open_file(output_id)) { ++ldi->ldi_file_num_lines_lost; } else if (ldi->ldi_file_num_lines_lost > 0 && 0 <= ldi->ldi_fd) { char buffer[BUFSIZ]; char *out = buffer; memset(buffer, 0, BUFSIZ); snprintf(buffer, BUFSIZ - 1, "[WARNING: %d lines lost because the PMIx process session directory did\n not exist when pmix_output() was invoked]\n", ldi->ldi_file_num_lines_lost); write(ldi->ldi_fd, buffer, (int)strlen(buffer)); ldi->ldi_file_num_lines_lost = 0; if (out != buffer) { free(out); } } } if (ldi->ldi_fd != -1) { write(ldi->ldi_fd, out, (int)strlen(out)); } } free(str); } return rc; }
FileMapper::FileMapper(std::string file) : d(new FileMapper_private) { if(!open_file(file)) fprintf(stderr, "FileMapper: Failed to open %s file!\n", file.c_str()); }
ssize_t VIsoFile::read(void *buf, size_t nbyte) { DirList *dirList; uint64_t remaining, to_read; uint64_t r; uint8_t *p; if (!fsBuf) return -1; remaining = nbyte; r = 0; p = (uint8_t *)buf; if (vFilePtr >= totalSize || remaining == 0) { return 0; } else if (vFilePtr < 0) { return -1; } if (vFilePtr < fsBufSize) { // Read FS structure from RAM to_read = MIN(fsBufSize-vFilePtr, remaining); memcpy(p, fsBuf+vFilePtr, to_read); remaining -= to_read; r += to_read; p += to_read; vFilePtr += to_read; } if (remaining == 0 || vFilePtr >= totalSize) return r; if (vFilePtr < padAreaStart) { // Read from file(s) dirList = rootList; while (dirList) { FileList *fileList = dirList->fileList; while (fileList) { uint64_t fStart = (uint64_t)fsBufSize + (uint64_t)fileList->rlba * 0x800; uint64_t fEnd = fStart + fileList->size; uint64_t fEndSector = ((fEnd+0x7ffULL)&~0x7ffULL); if (vFilePtr >= fStart && vFilePtr < fEndSector) { if (fileList->multipart) { fprintf(stderr, "Sorry no support for 666 files. I have the feeling that your game is about to crash ^_^\n"); return r; } if (vFilePtr < fEnd) { file_t fd; ssize_t this_r; to_read = MIN(fileList->size-(vFilePtr-fStart), remaining); fd = open_file(fileList->path, O_RDONLY); if (!FD_OK(fd)) { fprintf(stderr, "VISO: file %s cannot be opened!\n", fileList->path); return r; } seek_file(fd, vFilePtr-fStart, SEEK_SET); this_r = read_file(fd, p, to_read); close_file(fd); if (this_r < 0) { fprintf(stderr, "VISO: read_file failed on %s\n", fileList->path); return r; } if (this_r != to_read) { fprintf(stderr, "VISO: read on file %s returned less data than expected (file modified?)\n", fileList->path); return r; } remaining -= to_read; r += to_read; p += to_read; vFilePtr += to_read; } if (remaining > 0 && fEnd != fEndSector) { // This is a zero area after the file to fill the sector to_read = MIN((fEndSector-fEnd)-(vFilePtr-fEnd), remaining); memset(p, 0, to_read); remaining -= to_read; r += to_read; p += to_read; vFilePtr += to_read; } if (remaining == 0) return r; } fileList = fileList->next; } dirList = dirList->next; } } if (vFilePtr >= padAreaStart && vFilePtr < totalSize) { // Pad at the end to_read = MIN(padAreaSize-(vFilePtr-padAreaStart), remaining); memset(p, 0, to_read); remaining -= to_read; r += to_read; p += to_read; vFilePtr += to_read; } return r; }
FileMapper::FileMapper(const FileMapper &fm) : d(new FileMapper_private) { if(fm.d->m_Address && !open_file(fm.d->m_path)) d->m_error = fm.d->m_error; }
static void check_gt(args_t *args) { int i,ret, *gt2ipl = NULL, m_gt2ipl = 0, *gt_arr = NULL, ngt_arr = 0; int fake_pls = args->no_PLs; // Initialize things: check which tags are defined in the header, sample names etc. if ( bcf_hdr_id2int(args->gt_hdr, BCF_DT_ID, "GT")<0 ) error("[E::%s] GT not present in the header of %s?\n", __func__, args->files->readers[1].fname); if ( bcf_hdr_id2int(args->sm_hdr, BCF_DT_ID, "PL")<0 ) { if ( bcf_hdr_id2int(args->sm_hdr, BCF_DT_ID, "GT")<0 ) error("[E::%s] Neither PL nor GT present in the header of %s\n", __func__, args->files->readers[0].fname); if ( !args->no_PLs ) fprintf(pysam_stderr,"Warning: PL not present in the header of %s, using GT instead\n", args->files->readers[0].fname); fake_pls = 1; } FILE *fp = args->plot ? open_file(NULL, "w", "%s.tab", args->plot) : pysam_stdout; print_header(args, fp); int tgt_isample = -1, query_isample = 0; if ( args->target_sample ) { tgt_isample = bcf_hdr_id2int(args->gt_hdr, BCF_DT_SAMPLE, args->target_sample); if ( tgt_isample<0 ) error("No such sample in %s: [%s]\n", args->files->readers[1].fname, args->target_sample); } if ( args->all_sites ) { if ( tgt_isample==-1 ) { fprintf(pysam_stderr,"No target sample selected for comparison, using the first sample in %s: %s\n", args->gt_fname,args->gt_hdr->samples[0]); tgt_isample = 0; } } if ( args->query_sample ) { query_isample = bcf_hdr_id2int(args->sm_hdr, BCF_DT_SAMPLE, args->query_sample); if ( query_isample<0 ) error("No such sample in %s: [%s]\n", args->files->readers[0].fname, args->query_sample); } if ( args->all_sites ) fprintf(fp, "# [1]SC, Site by Site Comparison\t[2]Chromosome\t[3]Position\t[4]-g alleles\t[5]-g GT (%s)\t[6]match log LK\t[7]Query alleles\t[8-]Query PLs (%s)\n", args->gt_hdr->samples[tgt_isample],args->sm_hdr->samples[query_isample]); // Main loop float prev_lk = 0; while ( (ret=bcf_sr_next_line(args->files)) ) { if ( ret!=2 ) continue; bcf1_t *sm_line = args->files->readers[0].buffer[0]; // the query file bcf1_t *gt_line = args->files->readers[1].buffer[0]; // the -g target file bcf_unpack(sm_line, BCF_UN_FMT); bcf_unpack(gt_line, BCF_UN_FMT); // Init mapping from target genotype index to the sample's PL fields int n_gt2ipl = gt_line->n_allele*(gt_line->n_allele + 1)/2; if ( n_gt2ipl > m_gt2ipl ) { m_gt2ipl = n_gt2ipl; gt2ipl = (int*) realloc(gt2ipl, sizeof(int)*m_gt2ipl); } if ( !init_gt2ipl(args, gt_line, sm_line, gt2ipl, n_gt2ipl) ) continue; // Target genotypes int ngt, npl; if ( (ngt=bcf_get_genotypes(args->gt_hdr, gt_line, >_arr, &ngt_arr)) <= 0 ) error("GT not present at %s:%d?", args->gt_hdr->id[BCF_DT_CTG][gt_line->rid].key, gt_line->pos+1); ngt /= bcf_hdr_nsamples(args->gt_hdr); if ( ngt!=2 ) continue; // checking only diploid genotypes // Sample PLs if ( !fake_pls ) { if ( (npl=bcf_get_format_int32(args->sm_hdr, sm_line, "PL", &args->pl_arr, &args->npl_arr)) <= 0 ) { if ( sm_line->n_allele==1 ) { // PL values may not be present when ALT=. (mpileup/bcftools output), in that case // switch automatically to GT at these sites npl = fake_PLs(args, args->sm_hdr, sm_line); } else error("PL not present at %s:%d?\n", args->sm_hdr->id[BCF_DT_CTG][sm_line->rid].key, sm_line->pos+1); } else npl /= bcf_hdr_nsamples(args->sm_hdr); } else npl = fake_PLs(args, args->sm_hdr, sm_line); // Calculate likelihoods for all samples, assuming diploid genotypes // For faster access to genotype likelihoods (PLs) of the query sample int max_ipl, *pl_ptr = args->pl_arr + query_isample*npl; double sum_pl = 0; // for converting PLs to probs for (max_ipl=0; max_ipl<npl; max_ipl++) { if ( pl_ptr[max_ipl]==bcf_int32_vector_end ) break; if ( pl_ptr[max_ipl]==bcf_int32_missing ) continue; sum_pl += pow(10, -0.1*pl_ptr[max_ipl]); } if ( sum_pl==0 ) continue; // no PLs present if ( fake_pls && args->no_PLs==1 ) sum_pl = -1; // The main stats: concordance of the query sample with the target -g samples for (i=0; i<bcf_hdr_nsamples(args->gt_hdr); i++) { int *gt_ptr = gt_arr + i*ngt; if ( gt_ptr[1]==bcf_int32_vector_end ) continue; // skip haploid genotypes if ( bcf_gt_is_missing(gt_ptr[0]) || bcf_gt_is_missing(gt_ptr[1]) ) continue; int a = bcf_gt_allele(gt_ptr[0]); int b = bcf_gt_allele(gt_ptr[1]); if ( args->hom_only && a!=b ) continue; // heterozygous genotype int igt_tgt = igt_tgt = bcf_alleles2gt(a,b); // genotype index in the target file int igt_qry = gt2ipl[igt_tgt]; // corresponding genotype in query file if ( igt_qry>=max_ipl || pl_ptr[igt_qry]<0 ) continue; // genotype not present in query sample: haploid or missing args->lks[i] += sum_pl<0 ? -pl_ptr[igt_qry] : log(pow(10, -0.1*pl_ptr[igt_qry])/sum_pl); args->sites[i]++; } if ( args->all_sites ) { // Print LKs at all sites for debugging int *gt_ptr = gt_arr + tgt_isample*ngt; if ( gt_ptr[1]==bcf_int32_vector_end ) continue; // skip haploid genotypes int a = bcf_gt_allele(gt_ptr[0]); int b = bcf_gt_allele(gt_ptr[1]); if ( args->hom_only && a!=b ) continue; // heterozygous genotype fprintf(fp, "SC\t%s\t%d", args->gt_hdr->id[BCF_DT_CTG][gt_line->rid].key, gt_line->pos+1); for (i=0; i<gt_line->n_allele; i++) fprintf(fp, "%c%s", i==0?'\t':',', gt_line->d.allele[i]); fprintf(fp, "\t%s/%s", a>=0 ? gt_line->d.allele[a] : ".", b>=0 ? gt_line->d.allele[b] : "."); fprintf(fp, "\t%f", args->lks[query_isample]-prev_lk); prev_lk = args->lks[query_isample]; int igt, *pl_ptr = args->pl_arr + query_isample*npl; // PLs of the query sample for (i=0; i<sm_line->n_allele; i++) fprintf(fp, "%c%s", i==0?'\t':',', sm_line->d.allele[i]); for (igt=0; igt<npl; igt++) if ( pl_ptr[igt]==bcf_int32_vector_end ) break; else if ( pl_ptr[igt]==bcf_int32_missing ) fprintf(fp, "."); else fprintf(fp, "\t%d", pl_ptr[igt]); fprintf(fp, "\n"); } } free(gt2ipl); free(gt_arr); free(args->pl_arr); free(args->tmp_arr); // To be able to plot total discordance (=number of mismatching GTs with -G1) in the same // plot as discordance per site, the latter must be scaled to the same range int nsamples = bcf_hdr_nsamples(args->gt_hdr); double extreme_lk = 0, extreme_lk_per_site = 0; for (i=0; i<nsamples; i++) { if ( args->lks[i] < extreme_lk ) extreme_lk = args->lks[i]; if ( args->sites[i] && args->lks[i]/args->sites[i] < extreme_lk_per_site ) extreme_lk_per_site = args->lks[i]/args->sites[i]; } // Sorted output double **p = (double**) malloc(sizeof(double*)*nsamples); for (i=0; i<nsamples; i++) p[i] = &args->lks[i]; qsort(p, nsamples, sizeof(int*), cmp_doubleptr); fprintf(fp, "# [1]CN\t[2]Discordance with %s (total)\t[3]Discordance (avg score per site)\t[4]Number of sites compared\t[5]Sample\t[6]Sample ID\n", args->sm_hdr->samples[query_isample]); for (i=0; i<nsamples; i++) { int idx = p[i] - args->lks; double per_site = 0; if ( args->sites[idx] ) { if ( args->sites[idx] && extreme_lk_per_site ) { per_site = args->lks[idx]/args->sites[idx]; per_site *= extreme_lk / extreme_lk_per_site; } else per_site = 0; } fprintf(fp, "CN\t%e\t%e\t%.0f\t%s\t%d\n", fabs(args->lks[idx]), fabs(per_site), args->sites[idx], args->gt_hdr->samples[idx], i); } if ( args->plot ) { fclose(fp); plot_check(args, args->target_sample ? args->target_sample : "", args->sm_hdr->samples[query_isample]); } }
void net_reload() { if (prot) { if (net_server) { if (current_level) delete current_level; bFILE *fp; if (!reload_start()) return ; do { // make sure server saves the file fp=open_file(NET_STARTFILE,"rb"); if (fp->open_failure()) { delete fp; fp=NULL; } } while (!fp); spec_directory sd(fp); spec_entry *e=sd.find("Copyright 1995 Crack dot Com, All Rights reserved"); if (!e) { the_game->show_help("This level is missing copyright information, cannot load\n"); current_level=new level(100,100,"untitled"); the_game->need_refresh(); } else current_level=new level(&sd,fp,NET_STARTFILE); delete fp; base->current_tick=(current_level->tick_counter()&0xff); reload_end(); } else if (current_level) { join_struct *join_list=base->join_list; while (join_list) { view *f=player_list; for (;f && f->next;f=f->next); // find last player, add one for pn int i,st=0; for (i=0;i<total_objects;i++) if (!strcmp(object_names[i],"START")) st=i; game_object *o=create(current_start_type,0,0); game_object *start=current_level->get_random_start(320,NULL); if (start) { o->x=start->x; o->y=start->y; } else { o->x=100; o->y=100; } f->next=new view(o,NULL,join_list->client_id); strcpy(f->next->name,join_list->name); o->set_controller(f->next); if (start) current_level->add_object_after(o,start); else current_level->add_object(o); view *v=f->next; join_list=join_list->next; } base->join_list=NULL; current_level->save(NET_STARTFILE,1); base->mem_lock=0; jwindow *j=eh->new_window(0,yres/2,-1,-1,new info_field(WINDOW_FRAME_LEFT, WINDOW_FRAME_TOP, 0,symbol_str("resync"), new button(WINDOW_FRAME_LEFT, WINDOW_FRAME_TOP+eh->font()->height()+5,ID_NET_DISCONNECT, symbol_str("slack"),NULL)),symbol_str("hold!")) ; eh->flush_screen(); if (!reload_start()) return ; base->input_state=INPUT_RELOAD; // if someone missed the game tick with the RELOAD data in it, make sure the get it // wait for all client to reload the level with the new players do { service_net_request(); if (eh->event_waiting()) { event ev; do { eh->get_event(ev); if (ev.type==EV_MESSAGE && ev.message.id==ID_NET_DISCONNECT) { if (game_face) game_face->end_reload(1); base->input_state=INPUT_PROCESSING; } } while (eh->event_waiting()); eh->flush_screen(); } else { if (idle_man) idle_man->idle(); } } while (!reload_end()); eh->close_window(j); unlink(NET_STARTFILE); the_game->reset_keymap(); base->input_state=INPUT_COLLECTING; } } }
static void plot_check(args_t *args, char *target_sample, char *query_sample) { char *fname; FILE *fp = open_file(&fname, "w", "%s.py", args->plot); fprintf(fp, "import matplotlib as mpl\n" "mpl.use('Agg')\n" "import matplotlib.pyplot as plt\n" "import matplotlib.gridspec as gridspec\n" "import csv\n" "csv.register_dialect('tab', delimiter='\\t', quoting=csv.QUOTE_NONE)\n" "\n" "sample_ids = False\n" "\n" "dat = []\n" "with open('%s.tab', 'rb') as f:\n" " reader = csv.reader(f, 'tab')\n" " for row in reader:\n" " if row[0][0]=='#': continue\n" " if row[0]!='CN': continue\n" " tgt = 0\n" " if row[4]=='%s': tgt = 1\n" " dat.append([float(row[1]), float(row[2]), float(row[3]), tgt, row[4]])\n" "\n" "dat = sorted(dat)\n" "\n" "iq = -1; dp = 0\n" "for i in range(len(dat)):\n" " if iq==-1 and dat[i][3]==1: iq = i\n" " dp += dat[i][2]\n" "dp /= len(dat)\n" "\n" "fig,ax1 = plt.subplots(figsize=(8,5))\n" "ax2 = ax1.twinx()\n" "plots = ax1.plot([x[0] for x in dat],'o-', ms=3, color='g', mec='g', label='Discordance (total)')\n" "plots += ax1.plot([x[1] for x in dat], '^', ms=3, color='r', mec='r', label='Discordance (avg per site)')\n" "plots += ax2.plot([x[2] for x in dat],'v', ms=3, color='k', label='Number of sites')\n" "if iq!=-1:\n" " ax1.plot([iq],[dat[iq][0]],'o',color='orange', ms=9)\n" " ax1.annotate('%s',xy=(iq,dat[iq][0]), xytext=(5,5), textcoords='offset points',fontsize='xx-small',rotation=45,va='bottom',ha='left')\n" " ax1.plot([iq],[dat[iq][1]],'^',color='red', ms=5)\n" "for tl in ax1.get_yticklabels(): tl.set_color('g')\n" "for tl in ax2.get_yticklabels(): tl.set_color('k'); tl.set_fontsize(9)\n" "min_dp = min([x[2] for x in dat])\n" "max_dp = max([x[2] for x in dat])\n" "ax2.set_ylim(min_dp-1,max_dp+1)\n" "ax1.set_title('Discordance with %s')\n" "ax1.set_xlim(-0.05*len(dat),1.05*(len(dat)-1))\n" "ax1.set_xlabel('Sample ID')\n" "plt.subplots_adjust(left=0.1,right=0.9,bottom=0.1,top=0.9)\n" "if sample_ids:\n" " ax1.set_xticks(range(len(dat)))\n" " ax1.set_xticklabels([x[4] for x in dat],**{'rotation':45, 'ha':'right', 'fontsize':8})\n" " plt.subplots_adjust(bottom=0.2)\n" "ax1.set_ylabel('Discordance',color='g')\n" "ax2.set_ylabel('Number of sites',color='k')\n" "ax2.ticklabel_format(style='sci', scilimits=(-3,2), axis='y')\n" "ax1.ticklabel_format(style='sci', scilimits=(-3,2), axis='y')\n" "labels = [l.get_label() for l in plots]\n" "plt.legend(plots,labels,numpoints=1,markerscale=1,loc='best',prop={'size':10},frameon=False)\n" "plt.savefig('%s.png')\n" "plt.close()\n" "\n", args->plot, target_sample, target_sample, query_sample, args->plot ); fclose(fp); py_plot(fname); free(fname); }
void main(int argc, char *argv[]) { int i = 0, cmd = -1, fd = 0; char line[128], cname[64], temp_pathname[124], pathname[124] = "NULL", basename[124] = "NULL", dirname[124] = "NULL", parameter[124] = "NULL", *device; //GETS DISK NAME TO MOUNT /* printf("Enter the name of your disk image\n"); fgets(device, 128, stdin); device[strlen(device)-1] = 0; // kill the \n char at end */ device = "mydisk"; mount_root(device, &fd); while(1) { //printf("P%d running: ", running.uid); printf("nick's@linux:"); pwd(P0.cwd); printf("$ "); fgets(line, 128, stdin); line[strlen(line)-1] = 0; // kill the \n char at end if (line[0]==0) continue; sscanf(line, "%s %s %s", cname, pathname, parameter); if(strcmp(pathname,"NULL") != 0) strcpy(PATHNAME, pathname); if(strcmp(parameter,"NULL") != 0) strcpy(PARAMETER, parameter); cmd = findCmd(cname); // map cname to an index switch(cmd) { case 0 : menu(); break; case 1 : pwd(P0.cwd);printf("\n"); break; case 2 : ls(); break; case 3 : cd(); break; case 4 : make_dir(); break; case 5 : rmdir(); break; case 6 : creat_file(); break; case 7 : link(); break; case 8 : unlink(); break; case 9 : symlink(); break; case 10: rm_file(); break; case 11: chmod_file(); break; case 12: chown_file(); break; case 13: stat_file(); break; case 14: touch_file(); break; case 20: open_file(); break; //LEVEL 2 case 21: close_file((int)PATHNAME); break; case 22: pfd(); break; case 23: lseek_file(); break; case 24: //access_file(); break; break; case 25: //read_file(); break; case 26: write_file(); break; case 27: cat_file(); break; case 28: cp_file(); break; case 29: mv_file(); break; case 30: mount(); break; //LEVLEL 3 case 31: //umount(); break; case 32: //cs(); break; case 33: //do_fork(); break; case 34: //do_ps(); break; case 40: //sync(); break; case 41: quit(); break; case 42 : system("clear"); break; default: printf("invalid command\n"); break; } //RESET NAMES strcpy(parameter, "NULL"); strcpy(pathname, "NULL"); strcpy(PATHNAME, "NULL"); } }