int main(int argc, char *argv[]){
char *rec_sequence, *structure;
double min_en;
rec_sequence = structure = NULL;
/* initialization */
if (argc>1) {
read_parameter_file(argv[1]);
// printf("Params: '%s'\n",argv[1]);
}
/* main loop: continue until end of file */
while (!(get_multi_input_line(&rec_sequence, 0) & (VRNA_INPUT_ERROR | VRNA_INPUT_QUIT) )) {
/* init everything according to the data we've read */
int length = (int)strlen(rec_sequence);
structure = (char *)space(sizeof(char) *(length+1));
/* actual computations */
min_en = fold_par(rec_sequence, structure);
printf("%s\n%s (%6.2f)\n", rec_sequence, structure, min_en);
fflush(stdout);
/* clean up */
free(rec_sequence); free(structure);
rec_sequence = structure = NULL;
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
double s1;
int i, irank, nrank;
ARGC = argc;
ARGV = argv;
OUTPUT=0;
if(argc==1)
endrun("./QPM.mock qpm.bat_file > output");
read_parameter_file(argv[1]);
SIGMA_8Z0 = SIGMA_8;
SIGMA_8 = SIGMA_8*growthfactor(REDSHIFT);
fprintf(stdout,"SIGMA_8(Z=%.2f)= %.3f\n",REDSHIFT,SIGMA_8);
RESET_COSMOLOGY++;
if(argc>2)
{
if(atoi(argv[2])==999)
test();
else
SUBFRAC = atof(argv[2]);
}
if(Task.create_halos)
create_lognormal_halos();
if(Task.populate_simulation)
populate_simulation_hod();
exit(0);
}
CHARMMParameters::CHARMMParameters(base::TextInput top_file,
base::TextInput par_file,
bool translate_names_to_pdb) {
// Parameter objects are not designed to be added into other containers
set_was_used(true);
read_topology_file(top_file, translate_names_to_pdb);
if (par_file != base::TextInput()) {
read_parameter_file(par_file);
}
}
void initSeq(const char* param, const char* seq) {
int i; read_parameter_file(param);
c_P = get_scaled_parameters();
c_len = strlen(seq);
c_seq = malloc(c_len+1);
for (i=0; i<c_len; ++i) switch (seq[i]) {
case 'a': c_seq[i]=1; break;
case 'c': c_seq[i]=2; break;
case 'g': c_seq[i]=3; break;
case 'u': c_seq[i]=4; break;
default: exit(1);
}
}
/*--------------------------------------------------------------------------*/
int main(int argc, char *argv[]){
struct RNAalifold_args_info args_info;
unsigned int input_type;
char ffname[FILENAME_MAX_LENGTH], gfname[FILENAME_MAX_LENGTH], fname[FILENAME_MAX_LENGTH];
char *input_string, *string, *structure, *cstruc, *ParamFile, *ns_bases, *c;
int n_seq, i, length, sym, r, noPS, with_sci;
int endgaps, mis, circular, doAlnPS, doColor, doMEA, n_back, eval_energy, pf, istty;
double min_en, real_en, sfact, MEAgamma, bppmThreshold, betaScale;
char *AS[MAX_NUM_NAMES]; /* aligned sequences */
char *names[MAX_NUM_NAMES]; /* sequence names */
FILE *clust_file = stdin;
pf_paramT *pf_parameters;
model_detailsT md;
fname[0] = ffname[0] = gfname[0] = '\0';
string = structure = cstruc = ParamFile = ns_bases = NULL;
pf_parameters = NULL;
endgaps = mis = pf = circular = doAlnPS = doColor = n_back = eval_energy = oldAliEn = doMEA = ribo = noPS = 0;
do_backtrack = 1;
dangles = 2;
gquad = 0;
sfact = 1.07;
bppmThreshold = 1e-6;
MEAgamma = 1.0;
betaScale = 1.;
with_sci = 0;
set_model_details(&md);
/*
#############################################
# check the command line prameters
#############################################
*/
if(RNAalifold_cmdline_parser (argc, argv, &args_info) != 0) exit(1);
/* temperature */
if(args_info.temp_given) temperature = args_info.temp_arg;
/* structure constraint */
if(args_info.constraint_given) fold_constrained=1;
/* do not take special tetra loop energies into account */
if(args_info.noTetra_given) md.special_hp = tetra_loop=0;
/* set dangle model */
if(args_info.dangles_given){
if((args_info.dangles_arg != 0) && (args_info.dangles_arg != 2))
warn_user("required dangle model not implemented, falling back to default dangles=2");
else
md.dangles = dangles=args_info.dangles_arg;
}
/* do not allow weak pairs */
if(args_info.noLP_given) md.noLP = noLonelyPairs = 1;
/* do not allow wobble pairs (GU) */
if(args_info.noGU_given) md.noGU = noGU = 1;
/* do not allow weak closing pairs (AU,GU) */
if(args_info.noClosingGU_given) md.noGUclosure = no_closingGU = 1;
/* gquadruplex support */
if(args_info.gquad_given) md.gquad = gquad = 1;
/* sci computation */
if(args_info.sci_given) with_sci = 1;
/* do not convert DNA nucleotide "T" to appropriate RNA "U" */
/* set energy model */
if(args_info.energyModel_given) energy_set = args_info.energyModel_arg;
/* take another energy parameter set */
if(args_info.paramFile_given) ParamFile = strdup(args_info.paramFile_arg);
/* Allow other pairs in addition to the usual AU,GC,and GU pairs */
if(args_info.nsp_given) ns_bases = strdup(args_info.nsp_arg);
/* set pf scaling factor */
if(args_info.pfScale_given) sfact = args_info.pfScale_arg;
/* assume RNA sequence to be circular */
if(args_info.circ_given) circular=1;
/* do not produce postscript output */
if(args_info.noPS_given) noPS = 1;
/* partition function settings */
if(args_info.partfunc_given){
pf = 1;
if(args_info.partfunc_arg != -1)
do_backtrack = args_info.partfunc_arg;
}
/* MEA (maximum expected accuracy) settings */
if(args_info.MEA_given){
pf = doMEA = 1;
if(args_info.MEA_arg != -1)
MEAgamma = args_info.MEA_arg;
}
if(args_info.betaScale_given) betaScale = args_info.betaScale_arg;
/* set the bppm threshold for the dotplot */
if(args_info.bppmThreshold_given)
bppmThreshold = MIN2(1., MAX2(0.,args_info.bppmThreshold_arg));
/* set cfactor */
if(args_info.cfactor_given) cv_fact = args_info.cfactor_arg;
/* set nfactor */
if(args_info.nfactor_given) nc_fact = args_info.nfactor_arg;
if(args_info.endgaps_given) endgaps = 1;
if(args_info.mis_given) mis = 1;
if(args_info.color_given) doColor=1;
if(args_info.aln_given) doAlnPS=1;
if(args_info.old_given) oldAliEn = 1;
if(args_info.stochBT_given){
n_back = args_info.stochBT_arg;
do_backtrack = 0;
pf = 1;
init_rand();
}
if(args_info.stochBT_en_given){
n_back = args_info.stochBT_en_arg;
do_backtrack = 0;
pf = 1;
eval_energy = 1;
init_rand();
}
if(args_info.ribosum_file_given){
RibosumFile = strdup(args_info.ribosum_file_arg);
ribo = 1;
}
if(args_info.ribosum_scoring_given){
RibosumFile = NULL;
ribo = 1;
}
if(args_info.layout_type_given)
rna_plot_type = args_info.layout_type_arg;
/* alignment file name given as unnamed option? */
if(args_info.inputs_num == 1){
clust_file = fopen(args_info.inputs[0], "r");
if (clust_file == NULL) {
fprintf(stderr, "can't open %s\n", args_info.inputs[0]);
}
}
/* free allocated memory of command line data structure */
RNAalifold_cmdline_parser_free (&args_info);
/*
#############################################
# begin initializing
#############################################
*/
if(circular && gquad){
nrerror("G-Quadruplex support is currently not available for circular RNA structures");
}
make_pair_matrix();
if (circular && noLonelyPairs)
warn_user("depending on the origin of the circular sequence, "
"some structures may be missed when using --noLP\n"
"Try rotating your sequence a few times\n");
if (ParamFile != NULL) read_parameter_file(ParamFile);
if (ns_bases != NULL) {
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-') {
sym=1; c++;
}
while (*c!='\0') {
if (*c!=',') {
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1))) {
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
istty = isatty(fileno(stdout))&&isatty(fileno(stdin));
/*
########################################################
# handle user input from 'stdin' if necessary
########################################################
*/
if(fold_constrained){
if(istty){
print_tty_constraint_full();
print_tty_input_seq_str("");
}
input_type = get_input_line(&input_string, VRNA_INPUT_NOSKIP_COMMENTS);
if(input_type & VRNA_INPUT_QUIT){ return 0;}
else if((input_type & VRNA_INPUT_MISC) && (strlen(input_string) > 0)){
cstruc = strdup(input_string);
free(input_string);
}
else warn_user("constraints missing");
}
if (istty && (clust_file == stdin))
print_tty_input_seq_str("Input aligned sequences in clustalw or stockholm format\n(enter a line starting with \"//\" to indicate the end of your input)");
n_seq = read_clustal(clust_file, AS, names);
if (n_seq==0) nrerror("no sequences found");
if (clust_file != stdin) fclose(clust_file);
/*
########################################################
# done with 'stdin' handling, now init everything properly
########################################################
*/
length = (int) strlen(AS[0]);
structure = (char *)space((unsigned) length+1);
if(fold_constrained && cstruc != NULL)
strncpy(structure, cstruc, length);
if (endgaps)
for (i=0; i<n_seq; i++) mark_endgaps(AS[i], '~');
/*
########################################################
# begin actual calculations
########################################################
*/
if (circular) {
int i;
double s = 0;
min_en = circalifold((const char **)AS, structure);
for (i=0; AS[i]!=NULL; i++)
s += energy_of_circ_structure(AS[i], structure, -1);
real_en = s/i;
} else {
float *ens = (float *)space(2*sizeof(float));
min_en = alifold((const char **)AS, structure);
if(md.gquad)
energy_of_ali_gquad_structure((const char **)AS, structure, n_seq, ens);
else
energy_of_alistruct((const char **)AS, structure, n_seq, ens);
real_en = ens[0];
free(ens);
}
string = (mis) ? consens_mis((const char **) AS) : consensus((const char **) AS);
printf("%s\n%s", string, structure);
if(istty){
if(with_sci){
float sci = min_en;
float e_mean = 0;
for (i=0; AS[i]!=NULL; i++){
char *seq = get_ungapped_sequence(AS[i]);
char *str = (char *)space(sizeof(char) * (strlen(seq) + 1));
e_mean += fold(seq, str);
free(seq);
free(str);
}
e_mean /= i;
sci /= e_mean;
printf( "\n minimum free energy = %6.2f kcal/mol (%6.2f + %6.2f)"
"\n SCI = %2.4f\n",
min_en, real_en, min_en-real_en, sci);
} else
printf("\n minimum free energy = %6.2f kcal/mol (%6.2f + %6.2f)\n",
min_en, real_en, min_en - real_en);
} else {
if(with_sci){
float sci = min_en;
float e_mean = 0;
for (i=0; AS[i]!=NULL; i++){
char *seq = get_ungapped_sequence(AS[i]);
char *str = (char *)space(sizeof(char) * (strlen(seq) + 1));
e_mean += fold(seq, str);
free(seq);
free(str);
}
e_mean /= i;
sci /= e_mean;
printf(" (%6.2f = %6.2f + %6.2f) [%2.4f]\n", min_en, real_en, min_en-real_en, sci);
}
else
printf(" (%6.2f = %6.2f + %6.2f) \n", min_en, real_en, min_en-real_en );
}
strcpy(ffname, "alirna.ps");
strcpy(gfname, "alirna.g");
if (!noPS) {
char **A;
A = annote(structure, (const char**) AS);
if(md.gquad){
if (doColor)
(void) PS_rna_plot_a_gquad(string, structure, ffname, A[0], A[1]);
else
(void) PS_rna_plot_a_gquad(string, structure, ffname, NULL, A[1]);
} else {
if (doColor)
(void) PS_rna_plot_a(string, structure, ffname, A[0], A[1]);
else
(void) PS_rna_plot_a(string, structure, ffname, NULL, A[1]);
}
free(A[0]); free(A[1]); free(A);
}
if (doAlnPS)
PS_color_aln(structure, "aln.ps", (const char const **) AS, (const char const **) names);
/* free mfe arrays */
free_alifold_arrays();
if (pf) {
float energy, kT;
char * mfe_struc;
mfe_struc = strdup(structure);
kT = (betaScale*((temperature+K0)*GASCONST))/1000.; /* in Kcal */
pf_scale = exp(-(sfact*min_en)/kT/length);
if (length>2000) fprintf(stderr, "scaling factor %f\n", pf_scale);
fflush(stdout);
if (cstruc!=NULL) strncpy(structure, cstruc, length+1);
pf_parameters = get_boltzmann_factors_ali(n_seq, temperature, betaScale, md, pf_scale);
energy = alipf_fold_par((const char **)AS, structure, NULL, pf_parameters, do_backtrack, fold_constrained, circular);
if (n_back>0) {
/*stochastic sampling*/
for (i=0; i<n_back; i++) {
char *s;
double prob=1.;
s = alipbacktrack(&prob);
printf("%s ", s);
if (eval_energy ) printf("%6g %.2f ",prob, -1*(kT*log(prob)-energy));
printf("\n");
free(s);
}
}
if (do_backtrack) {
printf("%s", structure);
if (!istty) printf(" [%6.2f]\n", energy);
else printf("\n");
}
if ((istty)||(!do_backtrack))
printf(" free energy of ensemble = %6.2f kcal/mol\n", energy);
printf(" frequency of mfe structure in ensemble %g\n",
exp((energy-min_en)/kT));
if (do_backtrack) {
FILE *aliout;
cpair *cp;
char *cent;
double dist;
FLT_OR_DBL *probs = export_ali_bppm();
plist *pl, *mfel;
assign_plist_from_pr(&pl, probs, length, bppmThreshold);
assign_plist_from_db(&mfel, mfe_struc, 0.95*0.95);
if (!circular){
float *ens;
cent = get_centroid_struct_pr(length, &dist, probs);
ens=(float *)space(2*sizeof(float));
energy_of_alistruct((const char **)AS, cent, n_seq, ens);
/*cent_en = energy_of_struct(string, cent);*/ /*ali*/
printf("%s %6.2f {%6.2f + %6.2f}\n",cent,ens[0]-ens[1],ens[0],(-1)*ens[1]);
free(cent);
free(ens);
}
if(doMEA){
float mea, *ens;
plist *pl2;
assign_plist_from_pr(&pl2, probs, length, 1e-4/(1+MEAgamma));
mea = MEA(pl2, structure, MEAgamma);
ens = (float *)space(2*sizeof(float));
if(circular)
energy_of_alistruct((const char **)AS, structure, n_seq, ens);
else
ens[0] = energy_of_structure(string, structure, 0);
printf("%s {%6.2f MEA=%.2f}\n", structure, ens[0], mea);
free(ens);
free(pl2);
}
if (fname[0]!='\0') {
strcpy(ffname, fname);
strcat(ffname, "_ali.out");
} else strcpy(ffname, "alifold.out");
aliout = fopen(ffname, "w");
if (!aliout) {
fprintf(stderr, "can't open %s skipping output\n", ffname);
} else {
print_aliout(AS, pl, bppmThreshold, n_seq, mfe_struc, aliout);
}
fclose(aliout);
if (fname[0]!='\0') {
strcpy(ffname, fname);
strcat(ffname, "_dp.ps");
} else strcpy(ffname, "alidot.ps");
cp = make_color_pinfo(AS,pl, bppmThreshold, n_seq, mfel);
(void) PS_color_dot_plot(string, cp, ffname);
free(cp);
free(pl);
free(mfel);
}
free(mfe_struc);
free_alipf_arrays();
free(pf_parameters);
}
if (cstruc!=NULL) free(cstruc);
(void) fflush(stdout);
free(string);
free(structure);
for (i=0; AS[i]; i++) {
free(AS[i]); free(names[i]);
}
return 0;
}
int main(int argc, char **argv)
{
double s1, delta_vir, omega_m, x;
int i, j;
FILE *fp;
#ifdef PARALLEL
printf("STARTING>>>\n");
fflush(stdout);
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &ThisTask);
MPI_Comm_size(MPI_COMM_WORLD, &NTask);
printf("TASK %d reporting for duty.\n",ThisTask);
fflush(stdout);
#endif
ARGC = argc;
ARGV = argv;
OUTPUT=0;
HOD.fredc = HOD.freds = 1.0;
for(i=1; i<=99; ++i)
HOD.free[i]=0;
wp.esys=0;
Work.chi2=0;
Work.imodel=1;
USE_ERRORS = 0;
ITRANS=4;
HUBBLE=0.7;
BEST_FIT = 0;
HOD.M_sat_break = 1.0e14;
HOD.alpha1 = 1.0;
if(argc==1)
endrun("./HOD.x hod.bat_file > output");
read_parameter_file(argv[1]);
if(REDSHIFT>0)
{
SIGMA_8 = SIGMA_8*growthfactor(REDSHIFT);
HUBBLEZ = sqrt(OMEGA_M*pow(1+REDSHIFT,3.0)+1-OMEGA_M);
OMEGA_Z = OMEGA_M*pow(1+REDSHIFT,3.0)/(OMEGA_M*pow(1+REDSHIFT,3.0)+(1-OMEGA_M));
fprintf(stdout,"SIGMA_8(Z=%.3f)= %.4f\n",REDSHIFT,SIGMA_8);
fprintf(stdout,"H(Z=%.3f)/H0= %.4f\n",REDSHIFT,HUBBLEZ);
HOD.M_min = 0;
RESET_COSMOLOGY++;
set_HOD_params();
}
/* Output the virial overdensity for reference.
*/
if(OUTPUT)
{
omega_m=OMEGA_M*pow(1+REDSHIFT,3.0)/(OMEGA_M*pow(1+REDSHIFT,3.0)+(1-OMEGA_M));
x=omega_m-1;
delta_vir=(18*PI*PI+82*x-39*x*x)/(1+x);
printf("DELTA_VIR(Omega_m,z) = %f\n",delta_vir);
}
/* Do some initialization if we're doing SHMR
*/
if(SHMR_FLAG)
{
if(SATELLITE_PARAMETERIZATION)SHMR_PARAMS = 14;
if(VARIABLE_ALPHA)SHMR_PARAMS += 2;
if(VARIABLE_EXCLUSION)wpl.a[SHMR_PARAMS+1] = EXCLUSION_RADIUS;
wpl.ncf = SHMR_PARAMS + VARIABLE_EXCLUSION;
HOD.pdfs = 100;
HOD.pdfc = 101;
wpx.calculate_two_halo = 1;
input_stellar_mass_bins();
// if we have input from the prompt, take that
if(argc>2 && atoi(argv[2])!=999)
{
fp = openfile(argv[2]);
fscanf(fp,"%d %d",&i,&j);
for(i=1; i<=wpl.ncf; ++i)
fscanf(fp,"%lf",&wpl.a[i]);
fclose(fp);
}
}
for(i=1; i<=wpl.ncf; ++i)
printf("wpl.a[%d]= %e\n",i,wpl.a[i]);
/* LENSING TESTING FOR ALEXIE
*/
if(argc>2)
IDUM_MCMC=atoi(argv[2]);
SIGMA_8Z0 = 0.8;
if(argc>2)
if(atoi(argv[2])==999)
test(argc,argv);
/* If there's no cross-correlation function,
* set the second number density equal to the first
*/
if(!XCORR)
GALAXY_DENSITY2 = GALAXY_DENSITY;
/* Initialize the non-linear power spectrum.
*/
nonlinear_sigmac(8.0);
sigmac_interp(1.0E13);
sigmac_radius_interp(1.0);
/* Skip the HOD stuff if we're SHMR-ing it:
*/
if(SHMR_FLAG)
{
if(argc>2 && atoi(argv[2])==999)test(argc, argv);
if(argc>3 && atoi(argv[3])==999)test(argc, argv);
goto TASKS;
}
/* Get the galaxy bias factor
*/
s1=qromo(func_galaxy_bias,log(HOD.M_low),log(HOD.M_max),midpnt);
GALAXY_BIAS=s1/GALAXY_DENSITY;
if(OUTPUT)
fprintf(stdout,"Galaxy Bias bg= %f\n",GALAXY_BIAS);
fflush(stdout);
/* Get the galaxy satellite fraction
*/
s1=qromo(func_satellite_density,log(HOD.M_low),log(HOD.M_max),midpnt)/
GALAXY_DENSITY;
if(OUTPUT)
fprintf(stdout,"fsat %e\n",s1);
fflush(stdout);
/* Mean halo mass.
*/
if(OUTPUT)
fprintf(stdout,"M_eff %e\n",number_weighted_halo_mass());
fflush(stdout);
/* Set up BETA for wp integration.
*/
BETA = pow(OMEGA_M,0.6)/GALAXY_BIAS;
if(OUTPUT)
printf("BETA = %f\n",BETA);
TASKS:
tasks(argc,argv);
}
int main(int argc, char *argv[]){
struct RNAeval_args_info args_info;
char *string, *structure, *orig_sequence, *tmp;
char *rec_sequence, *rec_id, **rec_rest;
char fname[FILENAME_MAX_LENGTH];
char *ParamFile;
int i, length1, length2;
float energy;
int istty;
int circular=0;
int noconv=0;
int verbose = 0;
unsigned int rec_type, read_opt;
string = orig_sequence = ParamFile = NULL;
gquad = 0;
dangles = 2;
/*
#############################################
# check the command line parameters
#############################################
*/
if(RNAeval_cmdline_parser (argc, argv, &args_info) != 0) exit(1);
/* temperature */
if(args_info.temp_given) temperature = args_info.temp_arg;
/* do not take special tetra loop energies into account */
if(args_info.noTetra_given) tetra_loop=0;
/* set dangle model */
if(args_info.dangles_given){
if((args_info.dangles_arg < 0) || (args_info.dangles_arg > 3))
warn_user("required dangle model not implemented, falling back to default dangles=2");
else
dangles = args_info.dangles_arg;
}
/* do not convert DNA nucleotide "T" to appropriate RNA "U" */
if(args_info.noconv_given) noconv = 1;
/* set energy model */
if(args_info.energyModel_given) energy_set = args_info.energyModel_arg;
/* take another energy parameter set */
if(args_info.paramFile_given) ParamFile = strdup(args_info.paramFile_arg);
/* assume RNA sequence to be circular */
if(args_info.circ_given) circular=1;
/* logarithmic multiloop energies */
if(args_info.logML_given) logML = 1;
/* be verbose */
if(args_info.verbose_given) verbose = 1;
/* gquadruplex support */
if(args_info.gquad_given) gquad = 1;
/* free allocated memory of command line data structure */
RNAeval_cmdline_parser_free (&args_info);
/*
#############################################
# begin initializing
#############################################
*/
if (ParamFile!=NULL) read_parameter_file(ParamFile);
rec_type = read_opt = 0;
rec_id = rec_sequence = NULL;
rec_rest = NULL;
istty = isatty(fileno(stdout)) && isatty(fileno(stdin));
if(circular && gquad){
nrerror("G-Quadruplex support is currently not available for circular RNA structures");
}
/* set options we wanna pass to read_record */
if(istty){
read_opt |= VRNA_INPUT_NOSKIP_BLANK_LINES;
print_tty_input_seq_str("Use '&' to connect 2 sequences that shall form a complex.\n"
"Input sequence (upper or lower case) followed by structure");
}
/*
#############################################
# main loop: continue until end of file
#############################################
*/
while(
!((rec_type = read_record(&rec_id, &rec_sequence, &rec_rest, read_opt))
& (VRNA_INPUT_ERROR | VRNA_INPUT_QUIT))){
if(rec_id){
if(!istty) printf("%s\n", rec_id);
(void) sscanf(rec_id, ">%" XSTR(FILENAME_ID_LENGTH) "s", fname);
}
else fname[0] = '\0';
cut_point = -1;
string = tokenize(rec_sequence);
length2 = (int) strlen(string);
tmp = extract_record_rest_structure((const char **)rec_rest, 0, (rec_id) ? VRNA_OPTION_MULTILINE : 0);
if(!tmp)
nrerror("structure missing");
structure = tokenize(tmp);
length1 = (int) strlen(structure);
if(length1 != length2)
nrerror("structure and sequence differ in length!");
free(tmp);
/* convert DNA alphabet to RNA if not explicitely switched off */
if(!noconv) str_DNA2RNA(string);
/* store case-unmodified sequence */
orig_sequence = strdup(string);
/* convert sequence to uppercase letters only */
str_uppercase(string);
if(istty){
if (cut_point == -1)
printf("length = %d\n", length1);
else
printf("length1 = %d\nlength2 = %d\n", cut_point-1, length1-cut_point+1);
}
if(gquad)
energy = energy_of_gquad_structure(string, structure, verbose);
else
energy = (circular) ? energy_of_circ_structure(string, structure, verbose) : energy_of_structure(string, structure, verbose);
if (cut_point == -1)
printf("%s\n%s", orig_sequence, structure);
else {
char *pstring, *pstruct;
pstring = costring(orig_sequence);
pstruct = costring(structure);
printf("%s\n%s", pstring, pstruct);
free(pstring);
free(pstruct);
}
if (istty)
printf("\n energy = %6.2f\n", energy);
else
printf(" (%6.2f)\n", energy);
/* clean up */
(void) fflush(stdout);
if(rec_id) free(rec_id);
free(rec_sequence);
free(structure);
/* free the rest of current dataset */
if(rec_rest){
for(i=0;rec_rest[i];i++) free(rec_rest[i]);
free(rec_rest);
}
rec_id = rec_sequence = structure = NULL;
rec_rest = NULL;
free(string);
free(orig_sequence);
string = orig_sequence = NULL;
/* print user help for the next round if we get input from tty */
if(istty){
print_tty_input_seq_str("Use '&' to connect 2 sequences that shall form a complex.\n"
"Input sequence (upper or lower case) followed by structure");
}
}
return EXIT_SUCCESS;
}
/*! This function performs the initial set-up of the simulation. First, the
* parameterfile is set, then routines for setting units, reading
* ICs/restart-files are called, auxialiary memory is allocated, etc.
*/
void begrun(void)
{
struct global_data_all_processes all;
if(ThisTask == 0)
{
printf("\nThis is Gadget, version `%s'.\n", GADGETVERSION);
printf("\nRunning on %d processors.\n", NTask);
}
read_parameter_file(ParameterFile); /* ... read in parameters for this run */
allocate_commbuffers(); /* ... allocate buffer-memory for particle
exchange during force computation */
set_units();
#if defined(PERIODIC) && (!defined(PMGRID) || defined(FORCETEST))
ewald_init();
#endif
open_outputfiles();
random_generator = gsl_rng_alloc(gsl_rng_ranlxd1);
gsl_rng_set(random_generator, 42); /* start-up seed */
#ifdef PMGRID
long_range_init();
#endif
All.TimeLastRestartFile = CPUThisRun;
if(RestartFlag == 0 || RestartFlag == 2)
{
set_random_numbers();
init(); /* ... read in initial model */
}
else
{
all = All; /* save global variables. (will be read from restart file) */
restart(RestartFlag); /* ... read restart file. Note: This also resets
all variables in the struct `All'.
However, during the run, some variables in the parameter
file are allowed to be changed, if desired. These need to
copied in the way below.
Note: All.PartAllocFactor is treated in restart() separately.
*/
All.MinSizeTimestep = all.MinSizeTimestep;
All.MaxSizeTimestep = all.MaxSizeTimestep;
All.BufferSize = all.BufferSize;
All.BunchSizeForce = all.BunchSizeForce;
All.BunchSizeDensity = all.BunchSizeDensity;
All.BunchSizeHydro = all.BunchSizeHydro;
All.BunchSizeDomain = all.BunchSizeDomain;
All.TimeLimitCPU = all.TimeLimitCPU;
All.ResubmitOn = all.ResubmitOn;
All.TimeBetSnapshot = all.TimeBetSnapshot;
All.TimeBetStatistics = all.TimeBetStatistics;
All.CpuTimeBetRestartFile = all.CpuTimeBetRestartFile;
All.ErrTolIntAccuracy = all.ErrTolIntAccuracy;
All.MaxRMSDisplacementFac = all.MaxRMSDisplacementFac;
All.ErrTolForceAcc = all.ErrTolForceAcc;
All.TypeOfTimestepCriterion = all.TypeOfTimestepCriterion;
All.TypeOfOpeningCriterion = all.TypeOfOpeningCriterion;
All.NumFilesWrittenInParallel = all.NumFilesWrittenInParallel;
All.TreeDomainUpdateFrequency = all.TreeDomainUpdateFrequency;
All.SnapFormat = all.SnapFormat;
All.NumFilesPerSnapshot = all.NumFilesPerSnapshot;
All.MaxNumNgbDeviation = all.MaxNumNgbDeviation;
All.ArtBulkViscConst = all.ArtBulkViscConst;
All.OutputListOn = all.OutputListOn;
All.CourantFac = all.CourantFac;
All.OutputListLength = all.OutputListLength;
memcpy(All.OutputListTimes, all.OutputListTimes, sizeof(double) * All.OutputListLength);
strcpy(All.ResubmitCommand, all.ResubmitCommand);
strcpy(All.OutputListFilename, all.OutputListFilename);
strcpy(All.OutputDir, all.OutputDir);
strcpy(All.RestartFile, all.RestartFile);
strcpy(All.EnergyFile, all.EnergyFile);
strcpy(All.InfoFile, all.InfoFile);
strcpy(All.CpuFile, all.CpuFile);
strcpy(All.TimingsFile, all.TimingsFile);
strcpy(All.SnapshotFileBase, all.SnapshotFileBase);
if(All.TimeMax != all.TimeMax)
readjust_timebase(All.TimeMax, all.TimeMax);
}
#ifdef PMGRID
long_range_init_regionsize();
#endif
if(All.ComovingIntegrationOn)
init_drift_table();
if(RestartFlag == 2)
All.Ti_nextoutput = find_next_outputtime(All.Ti_Current + 1);
else
All.Ti_nextoutput = find_next_outputtime(All.Ti_Current);
All.TimeLastRestartFile = CPUThisRun;
}
/*--------------------------------------------------------------------------*/
int main(int argc, char *argv[]){
struct RNAplfold_args_info args_info;
unsigned int error = 0;
char fname[FILENAME_MAX_LENGTH], ffname[FILENAME_MAX_LENGTH], *c, *structure, *ParamFile, *ns_bases, *rec_sequence, *rec_id, **rec_rest, *orig_sequence;
unsigned int input_type;
int i, length, l, sym, r, istty, winsize, pairdist;
float cutoff;
int tempwin, temppair, tempunpaired;
FILE *pUfp = NULL, *spup = NULL;
double **pup = NULL; /*prob of being unpaired, lengthwise*/
int noconv, plexoutput, simply_putout, openenergies, binaries;
plist *pl, *dpp = NULL;
unsigned int rec_type, read_opt;
double betaScale;
pf_paramT *pf_parameters;
model_detailsT md;
dangles = 2;
cutoff = 0.01;
winsize = 70;
pairdist = 0;
unpaired = 0;
betaScale = 1.;
simply_putout = plexoutput = openenergies = noconv = 0;binaries=0;
tempwin = temppair = tempunpaired = 0;
structure = ParamFile = ns_bases = NULL;
rec_type = read_opt = 0;
rec_id = rec_sequence = orig_sequence = NULL;
rec_rest = NULL;
pf_parameters = NULL;
set_model_details(&md);
/*
#############################################
# check the command line parameters
#############################################
*/
if(RNAplfold_cmdline_parser (argc, argv, &args_info) != 0) exit(1);
/* temperature */
if(args_info.temp_given) temperature = args_info.temp_arg;
/* do not take special tetra loop energies into account */
if(args_info.noTetra_given) md.special_hp = tetra_loop=0;
/* set dangle model */
if(args_info.dangles_given){
if((args_info.dangles_arg != 0) && (args_info.dangles_arg != 2))
warn_user("required dangle model not implemented, falling back to default dangles=2");
else
md.dangles = dangles = args_info.dangles_arg;
}
/* do not allow weak pairs */
if(args_info.noLP_given) md.noLP = noLonelyPairs = 1;
/* do not allow wobble pairs (GU) */
if(args_info.noGU_given) md.noGU = noGU = 1;
/* do not allow weak closing pairs (AU,GU) */
if(args_info.noClosingGU_given) md.noGUclosure = no_closingGU = 1;
/* do not convert DNA nucleotide "T" to appropriate RNA "U" */
if(args_info.noconv_given) noconv = 1;
/* set energy model */
if(args_info.energyModel_given) energy_set = args_info.energyModel_arg;
/* take another energy parameter set */
if(args_info.paramFile_given) ParamFile = strdup(args_info.paramFile_arg);
/* Allow other pairs in addition to the usual AU,GC,and GU pairs */
if(args_info.nsp_given) ns_bases = strdup(args_info.nsp_arg);
/* set the maximum base pair span */
if(args_info.span_given) pairdist = args_info.span_arg;
/* set the pair probability cutoff */
if(args_info.cutoff_given) cutoff = args_info.cutoff_arg;
/* set the windowsize */
if(args_info.winsize_given) winsize = args_info.winsize_arg;
/* set the length of unstructured region */
if(args_info.ulength_given) unpaired = args_info.ulength_arg;
/* compute opening energies */
if(args_info.opening_energies_given) openenergies = 1;
/* print output on the fly */
if(args_info.print_onthefly_given) simply_putout = 1;
/* turn on RNAplex output */
if(args_info.plex_output_given) plexoutput = 1;
/* turn on binary output*/
if(args_info.binaries_given) binaries = 1;
if(args_info.betaScale_given) betaScale = args_info.betaScale_arg;
/* check for errorneous parameter options */
if((pairdist < 0) || (cutoff < 0.) || (unpaired < 0) || (winsize < 0)){
RNAplfold_cmdline_parser_print_help();
exit(EXIT_FAILURE);
}
/* free allocated memory of command line data structure */
RNAplfold_cmdline_parser_free(&args_info);
/*
#############################################
# begin initializing
#############################################
*/
if (ParamFile != NULL)
read_parameter_file(ParamFile);
if (ns_bases != NULL) {
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-') {
sym=1; c++;
}
while (*c!='\0') {
if (*c!=',') {
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1))) {
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
/* check parameter options again and reset to reasonable values if needed */
if(openenergies && !unpaired) unpaired = 31;
if(pairdist == 0) pairdist = winsize;
if(pairdist > winsize){
fprintf(stderr, "pairdist (-L %d) should be <= winsize (-W %d);"
"Setting pairdist=winsize\n",pairdist, winsize);
pairdist = winsize;
}
if(dangles % 2){
warn_user("using default dangles = 2");
dangles = 2;
}
istty = isatty(fileno(stdout))&&isatty(fileno(stdin));
read_opt |= VRNA_INPUT_NO_REST;
if(istty){
print_tty_input_seq();
read_opt |= VRNA_INPUT_NOSKIP_BLANK_LINES;
}
/*
#############################################
# main loop: continue until end of file
#############################################
*/
while(
!((rec_type = read_record(&rec_id, &rec_sequence, &rec_rest, read_opt))
& (VRNA_INPUT_ERROR | VRNA_INPUT_QUIT))){
/*
########################################################
# init everything according to the data we've read
########################################################
*/
if(rec_id){
if(!istty) printf("%s\n", rec_id);
(void) sscanf(rec_id, ">%" XSTR(FILENAME_ID_LENGTH) "s", fname);
}
else fname[0] = '\0';
length = (int)strlen(rec_sequence);
structure = (char *) space((unsigned) length+1);
/* convert DNA alphabet to RNA if not explicitely switched off */
if(!noconv) str_DNA2RNA(rec_sequence);
/* store case-unmodified sequence */
orig_sequence = strdup(rec_sequence);
/* convert sequence to uppercase letters only */
str_uppercase(rec_sequence);
if(istty) printf("length = %d\n", length);
/*
########################################################
# done with 'stdin' handling
########################################################
*/
if(length > 1000000){
if(!simply_putout && !unpaired){
printf("Switched to simple output mode!!!\n");
simply_putout = 1;
}
}
if(unpaired && simply_putout){
printf("Output simplification not possible if unpaired is switched on\n");
simply_putout = 0;
}
/* restore winsize if altered before */
if(tempwin != 0){
winsize = tempwin;
tempwin = 0;
}
/* restore pairdist if altered before */
if(temppair != 0){
pairdist = temppair;
temppair = 0;
}
/* restore ulength if altered before */
if(tempunpaired != 0){
unpaired = tempunpaired;
tempunpaired = 0;
}
/* adjust winsize, pairdist and ulength if necessary */
if(length < winsize){
fprintf(stderr, "WARN: window size %d larger than sequence length %d\n", winsize, length);
tempwin = winsize;
winsize = length;
if (pairdist>winsize) {
temppair=pairdist;
pairdist=winsize;
}
if (unpaired>winsize) {
tempunpaired=unpaired;
unpaired=winsize;
}
}
/*
########################################################
# begin actual computations
########################################################
*/
if (length >= 5){
/* construct output file names */
char fname1[FILENAME_MAX_LENGTH], fname2[FILENAME_MAX_LENGTH], fname3[FILENAME_MAX_LENGTH], fname4[FILENAME_MAX_LENGTH], fname_t[FILENAME_MAX_LENGTH];
strcpy(fname_t, (fname[0] != '\0') ? fname : "plfold");
strcpy(fname1, fname_t);
strcpy(fname2, fname_t);
strcpy(fname3, fname_t);
strcpy(fname4, fname_t);
strcpy(ffname, fname_t);
strcat(fname1, "_lunp");
strcat(fname2, "_basepairs");
strcat(fname3, "_uplex");
if(binaries){
strcat(fname4, "_openen_bin");
}
else{
strcat(fname4, "_openen");
}
strcat(ffname, "_dp.ps");
pf_parameters = get_boltzmann_factors(temperature, betaScale, md, -1);
if(unpaired > 0){
pup =(double **) space((length+1)*sizeof(double *));
pup[0] =(double *) space(sizeof(double)); /*I only need entry 0*/
pup[0][0] = unpaired;
}
pUfp = spup = NULL;
if(simply_putout){
spup = fopen(fname2, "w");
pUfp = (unpaired > 0) ? fopen(fname1, "w") : NULL;
pl = pfl_fold_par(rec_sequence, winsize, pairdist, cutoff, pup, &dpp, pUfp, spup, pf_parameters);
if(pUfp != NULL) fclose(pUfp);
if(spup != NULL) fclose(spup);
}
else{
pl = pfl_fold_par(rec_sequence, winsize, pairdist, cutoff, pup, &dpp, pUfp, spup, pf_parameters);
PS_dot_plot_turn(orig_sequence, pl, ffname, pairdist);
if (unpaired > 0){
if(plexoutput){
pUfp = fopen(fname3, "w");
putoutphakim_u(pup,length, unpaired, pUfp);
fclose(pUfp);
}
pUfp = fopen(openenergies ? fname4 : fname1, "w");
if(binaries){
putoutpU_prob_bin_par(pup, length, unpaired, pUfp, openenergies, pf_parameters);
}
else{
putoutpU_prob_par(pup, length, unpaired, pUfp, openenergies, pf_parameters);
}
fclose(pUfp);
}
}
if(pl) free(pl);
if(unpaired > 0){
free(pup[0]);
free(pup);
}
free(pf_parameters);
}
(void) fflush(stdout);
/* clean up */
if(rec_id) free(rec_id);
free(rec_sequence);
free(orig_sequence);
free(structure);
rec_id = rec_sequence = orig_sequence = NULL;
rec_rest = NULL;
/* print user help for the next round if we get input from tty */
if(istty) print_tty_input_seq();
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
char *line;
char *sequence;
char *structure = NULL;
char fname[21];
char *ParamFile = NULL;
char *ns_bases = NULL, *c;
int i, length, l, sym, r;
int istty;
double deltaf, deltap=0;
int delta=100;
int n_back = 0;
int noconv = 0;
int circ=0;
int dos=0;
int zuker=0;
do_backtrack = 1;
dangles = 2;
for (i=1; i<argc; i++) {
if (argv[i][0]=='-')
switch ( argv[i][1] )
{
case 'T': if (argv[i][2]!='\0') usage();
if(i==argc-1) usage();
r=sscanf(argv[++i], "%lf", &temperature);
if (r!=1) usage();
break;
case 'p':
if (argv[i][2]!='\0') usage();
if(i==argc-1) usage();
(void) sscanf(argv[++i], "%d", &n_back);
init_rand();
break;
case 'n':
if ( strcmp(argv[i], "-noGU" )==0) noGU=1;
if ( strcmp(argv[i], "-noCloseGU" ) ==0) no_closingGU=1;
if ( strcmp(argv[i], "-noLP")==0) noLonelyPairs=1;
if ( strcmp(argv[i], "-nsp") ==0) {
if (i==argc-1) usage();
ns_bases = argv[++i];
}
if ( strcmp(argv[i], "-noconv")==0) noconv=1;
break;
case '4':
tetra_loop=0;
break;
case 'C':
fold_constrained=1;
break;
case 'D':
dos=1;
print_energy = -999999;
break;
case 'd': dangles=0;
if (argv[i][2]!='\0') {
r=sscanf(argv[i]+2, "%d", &dangles);
if (r!=1) usage();
}
break;
case 'P':
if (i==argc-1) usage();
ParamFile = argv[++i];
break;
case 's':
subopt_sorted=1;
break;
case 'l':
if (strcmp(argv[i],"-logML")==0) {
logML=1;
break;
}
else usage();
break;
case 'e':
if (i>=argc-1) usage();
if (strcmp(argv[i],"-ep")==0)
r=sscanf(argv[++i], "%lf", &deltap);
else {
r=sscanf(argv[++i], "%lf", &deltaf);
delta = (int) (0.1+deltaf*100);
}
if (r!=1) usage();
break;
case 'c':
if ( strcmp(argv[i], "-circ")==0) circ=1;
break;
case 'z':
zuker=1;
break;
default: usage();
}
}
if ((zuker)&&(circ)) {
printf("Sorry, zuker subopts not yet implemented for circfold\n");
usage();
}
if ((zuker)&&(n_back>0)) {
printf("Cna't do zuker subopts and stochastic subopts at the same time\n");
usage();
}
if (ParamFile != NULL)
read_parameter_file(ParamFile);
if (ns_bases != NULL) {
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-') {
sym=1; c++;
}
while (*c) {
if (*c!=',') {
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1))) {
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
istty = isatty(fileno(stdout))&&isatty(fileno(stdin));
if ((fold_constrained)&&(istty)) {
printf("Input constraints using the following notation:\n");
/* printf("| : paired with another base\n"); */
printf(". : no constraint at all\n");
printf("x : base must not pair\n");
}
do { /* main loop: continue until end of file */
cut_point = -1;
if (istty) {
printf("\nInput string (upper or lower case); @ to quit\n");
if (!zuker)printf("Use '&' to connect 2 sequences that shall form a complex.\n");
printf("%s\n", scale);
}
fname[0]='\0';
if ((line = get_line(stdin))==NULL) break;
/* skip comment lines and get filenames */
while ((*line=='*')||(*line=='\0')||(*line=='>')) {
if (*line=='>')
(void) sscanf(line, ">%20s", fname);
free(line);
if ((line = get_line(stdin))==NULL) break;;
}
if ((line==NULL)||strcmp(line,"@")==0) break;
sequence = tokenize(line); /* frees line */
length = (int) strlen(sequence);
structure = (char *) space((unsigned) length+1);
if (fold_constrained) {
char *cstruc;
cstruc = tokenize(get_line(stdin));
if (cstruc!=NULL) {
strncpy(structure, cstruc, length);
for (i=0; i<length; i++)
if (structure[i]=='|')
nrerror("constraints of type '|' not allowed");
free(cstruc);
}
}
for (l = 0; l < length; l++) {
sequence[l] = toupper(sequence[l]);
if (!noconv && sequence[l] == 'T') sequence[l] = 'U';
}
if (istty) {
if (cut_point == -1)
printf("length = %d\n", length);
else
printf("length1 = %d\nlength2 = %d\n",
cut_point-1, length-cut_point+1);
}
if ((logML!=0 || dangles==1 || dangles==3) && dos==0)
if (deltap<=0) deltap=delta/100. +0.001;
if (deltap>0)
print_energy = deltap;
/* first lines of output (suitable for sort +1n) */
if (fname[0] != '\0')
printf("> %s [%d]\n", fname, delta);
if (n_back>0) { /* stochastic backtrack */
double mfe, kT;
char *ss;
st_back=1;
ss = (char *) space(strlen(sequence)+1);
strncpy(ss, structure, length);
mfe = fold(sequence, ss);
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(1.03*mfe)/kT/length);
strncpy(ss, structure, length);
/* ignore return value, we are not interested in the free energy */
(circ) ? (void) pf_circ_fold(sequence, ss) : (void) pf_fold(sequence, ss);
free(ss);
for (i=0; i<n_back; i++) {
char *s;
s =(circ) ? pbacktrack_circ(sequence) : pbacktrack(sequence);
printf("%s\n", s);
free(s);
}
free_pf_arrays();
} else if (!zuker) { /* normal subopt */
(circ) ? subopt_circ(sequence, structure, delta, stdout) : subopt(sequence, structure, delta, stdout);
if (dos) {
int i;
for (i=0; i<= MAXDOS && i<=delta/10; i++) {
printf("%4d %6d\n", i, density_of_states[i]);
}
}
} else { /* Zuker suboptimals */
SOLUTION *zr;
int i;
if (cut_point!=-1) {
printf("Sorry, zuker subopts not yet implemented for cofold\n");
usage();
}
zr = zukersubopt(sequence);
putoutzuker(zr);
(void)fflush(stdout);
for (i=0; zr[i].structure; i++) {
free(zr[i].structure);
}
free(zr);
}
(void)fflush(stdout);
free(sequence);
free(structure);
} while (1);
return 0;
}
int main(int argc, char *argv[])
{
char *start, *structure, *rstart, *str2, *line;
char *ParamFile=NULL;
int i,j, length, l, hd;
double energy=0., kT;
int pf, mfe, istty;
int repeat, found;
do_backtrack = 0;
pf = 0;
mfe = 1;
repeat = 0;
init_rand();
for (i=1; i<argc; i++) {
if (argv[i][0]=='-')
switch ( argv[i][1] )
{
case 'a':
symbolset = argv[++i];
/* symbolset should only have uppercase characters */
for (l = 0; l < (int)strlen(symbolset); l++)
symbolset[l] = toupper(symbolset[l]);
break;
case 'T':
if (argv[i][2]!='\0') usage();
if (sscanf(argv[++i], "%lf", &temperature)==0)
usage();
break;
case 'F':
mfe = 0;
pf = 0;
for(j=2; j<(int)strlen(argv[i]); j++) {
switch( argv[i][j] ) {
case 'm' :
mfe = 1;
break;
case 'p' :
pf = 1; /* old version had dangles=0 here */
break;
default :
usage();
}
}
break;
case 'R':
repeat = REPEAT_DEFAULT;
if(++i<argc)
if (sscanf(argv[i], "%d", &repeat)==0)
usage();
break;
case 'n':
if (strcmp(argv[i], "-noGU" )==0) noGU=1;
else if (strcmp(argv[i], "-noLP" )==0) noLonelyPairs=1;
else usage();
break;
case '4':
tetra_loop=0;
break;
case 'e':
if (sscanf(argv[++i],"%d", &energy_set)==0)
usage();
break;
case 'd':
dangles=0;
if (argv[i][2]!='\0')
if (sscanf(argv[i]+2, "%d", &dangles)==0)
usage();
break;
case 'f': /* when to stop RNAfold -p */
if (sscanf(argv[++i],"%f", &final_cost)==0)
usage();
break;
case 'P':
if (++i<argc)
ParamFile = argv[i];
else
usage();
break;
case 'v':
inv_verbose = 1;
break;
default:
usage();
}
}
kT = (temperature+273.15)*1.98717/1000.0;
istty = (isatty(fileno(stdout))&&isatty(fileno(stdin)));
if (ParamFile!=NULL)
read_parameter_file(ParamFile);
give_up = (repeat<0);
do {
if (istty) {
printf("\nInput structure & start string"
" (lower case letters for const positions)\n"
" @ to quit, and 0 for random start string\n");
printf("%s\n", scale);
}
if ((line = get_line(stdin))==NULL) break;
/* read structure, skipping over comment lines */
while ((*line=='*')||(*line=='\0')||(*line=='>')) {
printf("%s\n", line);
free(line);
if ((line = get_line(stdin))==NULL) break;
}
/* stop at eof or '@' */
if (line==NULL) break;
if (strcmp(line, "@") == 0) {
free(line);
break;
}
structure = (char *) space(strlen(line)+1);
(void) sscanf(line,"%s",structure); /* scanf gets rid of trailing junk */
free(line);
length = (int) strlen(structure);
str2 = (char *) space((unsigned)length+1);
if ((line = get_line(stdin))!=NULL)
if (strcmp(line, "@") == 0) {
free(line);
break;
}
start = (char *) space((unsigned) length+1);
if (line !=NULL) {
(void) strncpy(start, line, length);
free(line);
}
if (istty) printf("length = %d\n", length);
if (repeat!=0) found = (repeat>0)? repeat : (-repeat);
else found = 1;
initialize_fold(length);
rstart = (char *) space((unsigned)length+1);
while(found>0) {
char *string;
string = (char *) space((unsigned)length+1);
strcpy(string, start);
for (i=0; i<length; i++) {
/* lower case characters are kept fixed, any other character
not in symbolset is replaced by a random character */
if (islower(string[i])) continue;
if (string[i]=='\0' || (strchr(symbolset,string[i])==NULL))
string[i]=symbolset[int_urn(0,strlen(symbolset)-1)];
}
strcpy(rstart, string); /* remember start string */
if (mfe) {
energy = inverse_fold(string, structure);
if( (repeat>=0) || (energy<=0.0) ) {
found--;
hd = hamming(rstart, string);
printf("%s %3d", string, hd);
if (energy>0) { /* no solution found */
printf(" d= %g\n", energy);
if(istty) {
energy = fold(string,str2);
printf("%s\n", str2);
}
} else printf("\n");
}
}
if (pf) {
if (!(mfe && give_up && (energy>0))) {
/* unless we gave up in the mfe part */
double prob, min_en, sfact=1.07;
/* get a reasonable pf_scale */
min_en = fold(string,str2);
pf_scale = exp(-(sfact*min_en)/kT/length);
init_pf_fold(length);
energy = inverse_pf_fold(string, structure);
prob = exp(-energy/kT);
hd = hamming(rstart, string);
printf("%s %3d (%g)\n", string, hd, prob);
free_pf_arrays();
}
if (!mfe) found--;
}
(void) fflush(stdout);
free(string);
}
free(rstart);
free_arrays();
free(structure);
free(str2);
free(start);
(void) fflush(stdout);
} while (1);
return 0;
}
int main(int argc, char *argv[])
{
char *string/*, *line*/;
char *structure=NULL, *cstruc=NULL;
/*char fname[53], ffname[60]; */
/*char *ParamFile=NULL; */
char *ns_bases=NULL, *c;
char *Concfile;
int i, length, l, sym/*, r*/;
double min_en;
double kT, sfact=1.07;
int pf=0, istty;
int noconv=0;
int doT=0; /*compute dimere free energies etc.*/
int doC=0; /*toggle to compute concentrations*/
int doQ=0; /*toggle to compute prob of base being paired*/
int cofi=0; /*toggle concentrations stdin / file*/
struct plist *prAB;
struct plist *prAA; /*pair probabilities of AA dimer*/
struct plist *prBB;
struct plist *prA;
struct plist *prB;
struct plist *mfAB;
struct plist *mfAA; /*pair mfobabilities of AA dimer*/
struct plist *mfBB;
struct plist *mfA;
struct plist *mfB;
double *ConcAandB;
AjPSeq seq1 = NULL;
AjPFile confile1 = NULL;
AjPSeq seq2 = NULL;
AjPFile confile2 = NULL;
AjPFile concfile = NULL;
AjPFile paramfile = NULL;
AjPFile outf = NULL;
AjPFile essfile = NULL;
AjPFile dotfile = NULL;
AjPFile aoutf = NULL;
AjPFile aaoutf = NULL;
AjPFile boutf = NULL;
AjPFile bboutf = NULL;
AjPFile aboutf = NULL;
AjPStr seqstring1 = NULL;
AjPStr constring1 = NULL;
AjPStr constring2 = NULL;
float eT = 0.;
AjBool eGU;
AjBool eclose;
AjBool lonely;
AjBool convert;
AjPStr ensbases = NULL;
AjBool etloop;
AjPStr eenergy = NULL;
char ewt = '\0';
float escale = 0.;
AjPStr edangles = NULL;
char edangle = '\0';
/* AjBool dimers; */
/* AjBool paired; */
embInitPV("vrnacofold",argc,argv,"VIENNA",VERSION);
seqstring1 = ajStrNew();
constring1 = ajStrNew();
constring2 = ajStrNew();
seq1 = ajAcdGetSeq("asequence");
confile1 = ajAcdGetInfile("aconstraintfile");
seq2 = ajAcdGetSeq("bsequence");
confile2 = ajAcdGetInfile("bconstraintfile");
paramfile = ajAcdGetInfile("paramfile");
eT = ajAcdGetFloat("temperature");
eGU = ajAcdGetBoolean("gu");
eclose = ajAcdGetBoolean("closegu");
lonely = ajAcdGetBoolean("lp");
convert = ajAcdGetBoolean("convert");
ensbases = ajAcdGetString("nsbases");
etloop = ajAcdGetBoolean("tetraloop");
eenergy = ajAcdGetListSingle("energy");
escale = ajAcdGetFloat("scale");
edangles = ajAcdGetListSingle("dangles");
/* dimers = ajAcdGetBoolean("dimers"); */
/* paired = ajAcdGetBoolean("paired"); */
outf = ajAcdGetOutfile("outfile");
essfile = ajAcdGetOutfile("ssoutfile");
/* concfile = ajAcdGetInfile("concentrationfile"); */
/* dotfile = ajAcdGetOutfile("dotoutfile"); */
/*
aoutf = ajAcdGetOutfile("aoutfile");
aaoutf = ajAcdGetOutfile("aaoutfile");
boutf = ajAcdGetOutfile("boutfile");
bboutf = ajAcdGetOutfile("bboutfile");
aboutf = ajAcdGetOutfile("aboutfile");
*/
do_backtrack = 1;
pf = 0;
doT = 0;
doC = 0;
cofi = 0;
doQ = 0;
string = NULL;
Concfile = NULL;
istty = 0;
temperature = (double) eT;
noGU = (eGU) ? 0 : 1;
no_closingGU = (eclose) ? 0 : 1;
noLonelyPairs = (lonely) ? 0 : 1;
noconv = (convert) ? 0 : 1;
ns_bases = (ajStrGetLen(ensbases)) ? MAJSTRGETPTR(ensbases) : NULL;
tetra_loop = !!etloop;
ewt = *ajStrGetPtr(eenergy);
if(ewt == '0')
energy_set = 0;
else if(ewt == '1')
energy_set = 1;
else if(ewt == '2')
energy_set = 2;
sfact = (double) escale;
edangle = *ajStrGetPtr(edangles);
if(edangle == '0')
dangles = 0;
else if(edangle == '1')
dangles = 1;
else if(edangle == '2')
dangles = 2;
else if(edangle == '3')
dangles = 3;
if(paramfile)
read_parameter_file(paramfile);
if (ns_bases != NULL)
{
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-')
{
sym=1; c++;
}
while (*c!='\0')
{
if (*c!=',')
{
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1)))
{
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
cut_point = -1;
ajFmtPrintS(&seqstring1,"%s&%s",ajSeqGetSeqC(seq1),ajSeqGetSeqC(seq2));
string = tokenize(MAJSTRGETPTR(seqstring1)); /* frees line */
length = (int) strlen(string);
if (doC)
{
ConcAandB = read_concentrations(concfile);
}
structure = (char *) space((unsigned) length+1);
if(confile1)
{
vienna_GetConstraints(confile1,&constring1);
vienna_GetConstraints(confile2,&constring2);
ajStrAppendK(&constring1,'&');
ajStrAppendS(&constring1,constring2);
cstruc = tokenize(MAJSTRGETPTR(constring1));
if (cstruc!=NULL)
strncpy(structure, cstruc, length);
else
ajFatal("Constraints missing\n");
}
for (l = 0; l < length; l++)
{
string[l] = toupper(string[l]);
if (!noconv && string[l] == 'T') string[l] = 'U';
}
/*compute mfe of AB dimer*/
min_en = cofold(string, structure);
mfAB=(struct plist *) space(sizeof(struct plist) * (length+1));
mfAB=get_mfe_plist(mfAB);
if (cut_point == -1)
ajFmtPrintF(outf,"%s\n%s", string, structure); /*no cofold*/
else
{
char *pstring, *pstruct;
pstring = costring(string);
pstruct = costring(structure);
ajFmtPrintF(outf,"%s\n%s", pstring, pstruct);
free(pstring);
free(pstruct);
}
ajFmtPrintF(outf," (%6.2f)\n", min_en);
if (length<2000)
(void) PS_rna_plot(string, structure, essfile);
else
{
ajWarn("Structure too long, not doing xy_plot\n");
free_co_arrays();
}
/*compute partition function*/
if (pf)
{
cofoldF AB, AA, BB;
if (dangles==1)
{
dangles=2; /* recompute with dangles as in pf_fold() */
min_en = energy_of_struct(string, structure);
dangles=1;
}
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(sfact*min_en)/kT/length);
if (length>2000)
ajWarn("scaling factor %f\n", pf_scale);
init_co_pf_fold(length);
if (cstruc!=NULL)
strncpy(structure, cstruc, length+1);
AB = co_pf_fold(string, structure);
if (do_backtrack)
{
char *costruc;
costruc = (char *) space(sizeof(char)*(strlen(structure)+2));
if (cut_point<0)
ajFmtPrintF(outf,"%s", structure);
else
{
strncpy(costruc, structure, cut_point-1);
strcat(costruc, "&");
strcat(costruc, structure+cut_point-1);
ajFmtPrintF(outf,"%s", costruc);
}
ajFmtPrintF(outf," [%6.2f]\n", AB.FAB);
}
if ((istty)||(!do_backtrack))
ajFmtPrintF(outf," free energy of ensemble = %6.2f kcal/mol\n",
AB.FAB);
ajFmtPrintF(outf," frequency of mfe structure in ensemble %g",
exp((AB.FAB-min_en)/kT));
ajFmtPrintF(outf," , delta G binding=%6.2f\n", AB.FcAB - AB.FA - AB.FB);
prAB=(struct plist *) space(sizeof(struct plist) * (2*length));
prAB=get_plist(prAB, length,0.00001);
/* if (doQ) make_probsum(length,fname); */ /*compute prob of base paired*/
/* free_co_arrays(); */
if (doT)
{ /* cofold of all dimers, monomers */
int Blength, Alength;
char *Astring, *Bstring;
char *Newstring;
/*char Newname[30];*/
char comment[80];
if (cut_point<0)
{
free(mfAB);
free(prAB);
ajFatal("Sorry, I cannot do that with only one molecule, "
"please give me two\n");
}
if (dangles==1)
dangles=2;
Alength=cut_point-1; /*length of first molecule*/
Blength=length-cut_point+1; /*length of 2nd molecule*/
/*Sequence of first molecule*/
Astring=(char *)space(sizeof(char)*(Alength+1));
/*Sequence of second molecule*/
Bstring=(char *)space(sizeof(char)*(Blength+1));
strncat(Astring,string,Alength);
strncat(Bstring,string+Alength,Blength);
/* compute AA dimer */
prAA=(struct plist *) space(sizeof(struct plist) * (4*Alength));
mfAA=(struct plist *) space(sizeof(struct plist) * (Alength+1));
AA=do_partfunc(Astring, Alength, 2, &prAA, &mfAA);
/* compute BB dimer */
prBB=(struct plist *) space(sizeof(struct plist) * (4*Blength));
mfBB=(struct plist *) space(sizeof(struct plist) * (Blength+1));
BB=do_partfunc(Bstring, Blength, 2, &prBB, &mfBB);
/*free_co_pf_arrays();*/
/* compute A monomer */
prA=(struct plist *) space(sizeof(struct plist) * (2*Alength));
mfA=(struct plist *) space(sizeof(struct plist) * (Alength+1));
do_partfunc(Astring, Alength, 1, &prA, &mfA);
/* compute B monomer */
prB=(struct plist *) space(sizeof(struct plist) * (2*Blength));
mfB=(struct plist *) space(sizeof(struct plist) * (Blength+1));
do_partfunc(Bstring, Blength, 1, &prB, &mfB);
compute_probabilities(AB.F0AB, AB.FA, AB.FB, prAB, prA, prB,
Alength);
compute_probabilities(AA.F0AB, AA.FA, AA.FA, prAA, prA, prA,
Alength);
compute_probabilities(BB.F0AB, BB.FA, BB.FA, prBB, prA, prB,
Blength);
ajFmtPrintF(outf,"Free Energies:\nAB\t\tAA\t\tBB\t\tA\t\tB\n%.6f"
"\t%6f\t%6f\t%6f\t%6f\n",
AB.FcAB, AA.FcAB, BB.FcAB, AB.FA, AB.FB);
if (doC)
{
do_concentrations(AB.FcAB, AA.FcAB, BB.FcAB, AB.FA, AB.FB,
ConcAandB, outf);
free(ConcAandB);/*freeen*/
}
/*AB dot_plot*/
/*write Free Energy into comment*/
sprintf(comment,"\n%%Heterodimer AB FreeEnergy= %.9f\n", AB.FcAB);
/*reset cut_point*/
cut_point=Alength+1;
(void)PS_dot_plot_list(string, aboutf, prAB, mfAB, comment);
/*AA dot_plot*/
sprintf(comment,"\n%%Homodimer AA FreeEnergy= %.9f\n",AA.FcAB);
/*write AA sequence*/
Newstring=(char*)space((2*Alength+1)*sizeof(char));
strcpy(Newstring,Astring);
strcat(Newstring,Astring);
(void)PS_dot_plot_list(Newstring, aaoutf, prAA, mfAA, comment);
free(Newstring);
/*BB dot_plot*/
sprintf(comment,"\n%%Homodimer BB FreeEnergy= %.9f\n",BB.FcAB);
/*write BB sequence*/
Newstring=(char*)space((2*Blength+1)*sizeof(char));
strcpy(Newstring,Bstring);
strcat(Newstring,Bstring);
/*reset cut_point*/
cut_point=Blength+1;
(void)PS_dot_plot_list(Newstring, bboutf, prBB, mfBB, comment);
free(Newstring);
/*A dot plot*/
/*reset cut_point*/
cut_point=-1;
sprintf(comment,"\n%%Monomer A FreeEnergy= %.9f\n",AB.FA);
/*write A sequence*/
(void)PS_dot_plot_list(Astring, aoutf, prA, mfA, comment);
/*B monomer dot plot*/
sprintf(comment,"\n%%Monomer B FreeEnergy= %.9f\n",AB.FB);
/*write B sequence*/
(void)PS_dot_plot_list(Bstring, boutf, prB, mfB, comment);
free(Astring);
free(Bstring);
free(prAB);
free(prAA);
free(prBB);
free(prA);
free(prB);
free(mfAB);
free(mfAA);
free(mfBB);
free(mfA);
free(mfB);
} /*end if(doT)*/
}/*end if(pf)*/
if (do_backtrack)
{
if (!doT)
{
if (pf)
{
(void) PS_dot_plot_list(string, dotfile, prAB, mfAB, "doof");
free(prAB);
}
free(mfAB);
}
}
if (!doT)
free_co_pf_arrays();
if (cstruc!=NULL)
free(cstruc);
free(string);
free(structure);
ajStrDel(&seqstring1);
ajStrDel(&constring1);
ajStrDel(&constring2);
ajSeqDel(&seq1);
ajSeqDel(&seq2);
ajStrDel(&ensbases);
ajStrDel(&eenergy);
ajStrDel(&edangles);
ajFileClose(&confile1);
ajFileClose(&confile2);
ajFileClose(¶mfile);
ajFileClose(&outf);
ajFileClose(&essfile);
if (length<2000)
free_co_arrays();
embExit();
return 0;
}
int main(int argc, char *argv[])
{
char *sequence;
char *structure = NULL;
char *ns_bases = NULL, *c;
int i, length, l, sym;
int istty;
double deltap=0.;
int delta=100;
int n_back = 0;
int noconv=0;
int circ=0;
int dos=0;
AjPSeq seq = NULL;
AjPFile confile = NULL;
AjPFile paramfile = NULL;
AjPFile outf = NULL;
AjPStr constring = NULL;
float eT = 0.;
AjBool eGU;
AjBool eclose;
AjBool lonely;
AjBool convert;
AjPStr ensbases = NULL;
AjBool etloop;
AjPStr edangles = NULL;
char edangle = '\0';
ajint len;
float erange;
float prange;
embInitPV("vrnasubopt",argc,argv,"VIENNA",VERSION);
constring = ajStrNew();
seq = ajAcdGetSeq("sequence");
confile = ajAcdGetInfile("constraintfile");
paramfile = ajAcdGetInfile("paramfile");
eT = ajAcdGetFloat("temperature");
circ = !!ajAcdGetBoolean("circular");
dos = !!ajAcdGetBoolean("dos");
eGU = ajAcdGetBoolean("gu");
eclose = ajAcdGetBoolean("closegu");
lonely = ajAcdGetBoolean("lp");
convert = ajAcdGetBoolean("convert");
ensbases = ajAcdGetString("nsbases");
etloop = ajAcdGetBoolean("tetraloop");
erange = ajAcdGetFloat("erange");
prange = ajAcdGetFloat("prange");
subopt_sorted = !!ajAcdGetBoolean("sort");
logML = !!ajAcdGetBoolean("logml");
n_back = ajAcdGetInt("nrandom");
edangles = ajAcdGetListSingle("dangles");
outf = ajAcdGetOutfile("outfile");
if(dos)
print_energy = -999999;
do_backtrack = 1;
istty = 0;
temperature = (double) eT;
noGU = (eGU) ? 0 : 1;
no_closingGU = (eclose) ? 0 : 1;
noLonelyPairs = (lonely) ? 0 : 1;
noconv = (convert) ? 0 : 1;
ns_bases = (ajStrGetLen(ensbases)) ? MAJSTRGETPTR(ensbases) : NULL;
tetra_loop = !!etloop;
delta = (int) (0.1 + erange * 100);
deltap = prange;
edangle = *ajStrGetPtr(edangles);
if(edangle == '0')
dangles = 0;
else if(edangle == '1')
dangles = 1;
else if(edangle == '2')
dangles = 2;
else if(edangle == '3')
dangles = 3;
if(paramfile)
read_parameter_file(paramfile);
if (ns_bases != NULL)
{
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-')
{
sym=1;
c++;
}
while (*c)
{
if (*c!=',')
{
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1)))
{
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
if(confile)
vienna_GetConstraints(confile,&constring);
if(n_back)
init_rand();
sequence = NULL;
structure = NULL;
length = ajSeqGetLen(seq);
sequence = (char *) space(length+1);
strcpy(sequence,ajSeqGetSeqC(seq));
len = ajStrGetLen(constring);
structure = (char *) space(length+1);
if(len)
{
fold_constrained = 1;
strcpy(structure,ajStrGetPtr(constring));
}
istty = 0;
if (fold_constrained)
{
for (i=0; i<length; i++)
if (structure[i]=='|')
ajFatal("Constraints of type '|' are not allowed\n");
}
for (l = 0; l < length; l++)
{
sequence[l] = toupper(sequence[l]);
if (!noconv && sequence[l] == 'T')
sequence[l] = 'U';
}
if ((logML!=0 || dangles==1 || dangles==3) && dos==0)
if (deltap<=0) deltap=delta/100. +0.001;
if (deltap>0)
print_energy = deltap;
/* first lines of output (suitable for sort +1n) */
ajFmtPrintF(outf,"> %s [%d]\n", ajSeqGetNameC(seq), delta);
if(n_back>0)
{
int i;
double mfe, kT;
char *ss;
st_back=1;
ss = (char *) space(strlen(sequence)+1);
strncpy(ss, structure, length);
mfe = (circ) ? circfold(sequence, ss) : fold(sequence, ss);
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(1.03*mfe)/kT/length);
strncpy(ss, structure, length);
/*
** we are not interested in the free energy but in the bppm, so we
** drop free energy into the void
*/
(circ) ? (void) pf_circ_fold(sequence, ss) :
(void) pf_fold(sequence, ss);
free(ss);
for (i=0; i<n_back; i++)
{
char *s;
s = (circ) ? pbacktrack_circ(sequence) : pbacktrack(sequence);
ajFmtPrintF(outf,"%s\n", s);
free(s);
}
free_pf_arrays();
}
else
{
(circ) ? subopt_circ(sequence, structure, delta, ajFileGetFileptr(outf)) :
subopt(sequence, structure, delta, ajFileGetFileptr(outf));
}
free(sequence);
free(structure);
ajSeqDel(&seq);
ajStrDel(&ensbases);
ajStrDel(&edangles);
ajFileClose(&confile);
ajFileClose(&outf);
ajFileClose(¶mfile);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
char *s1, *s2, *line;
char fname[13];
char *ParamFile=NULL;
char *ns_bases=NULL, *c;
int i, l, sym, r;
double deltaf;
double kT, sfact=1.07;
int pf=0, istty, delta=-1;
int noconv=0;
for (i=1; i<argc; i++) {
if (argv[i][0]=='-')
switch ( argv[i][1] )
{
case 'T': if (argv[i][2]!='\0') usage();
if(i==argc-1) usage();
r=sscanf(argv[++i], "%lf", &temperature);
if (!r) usage();
break;
case 'p':
fprintf(stderr, "partition function folding not yet implemented\n");
usage();
pf=1;
if (argv[i][2]!='\0')
(void) sscanf(argv[i]+2, "%d", &do_backtrack);
break;
case 'n':
if ( strcmp(argv[i], "-noGU")==0) noGU=1;
if ( strcmp(argv[i], "-noCloseGU")==0) no_closingGU=1;
if ( strcmp(argv[i], "-noLP")==0) noLonelyPairs=1;
if ( strcmp(argv[i], "-nsp") ==0) {
if (i==argc-1) usage();
ns_bases = argv[++i];
}
if ( strcmp(argv[i], "-noconv")==0) noconv=1;
break;
case '4':
tetra_loop=0;
break;
case 'e':
if (i>=argc-1) usage();
r=sscanf(argv[++i], "%lf", &deltaf);
if (r!=1) usage();
delta = (int) (0.1+deltaf*100);
break;
case 's': subopt_sorted=1;
break;
case 'd': dangles=0;
if (argv[i][2]!='\0') {
r=sscanf(argv[i]+2, "%d", &dangles);
if (r!=1) usage();
}
break;
case 'P':
if (i==argc-1) usage();
ParamFile = argv[++i];
break;
default: usage();
}
}
if (ParamFile != NULL)
read_parameter_file(ParamFile);
if (ns_bases != NULL) {
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-') {
sym=1; c++;
}
while (*c!='\0') {
if (*c!=',') {
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1))) {
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
istty = isatty(fileno(stdout))&&isatty(fileno(stdin));
do { /* main loop: continue until end of file */
duplexT mfe, *subopt;
if (istty) {
printf("\nInput two sequences (one line each); @ to quit\n");
printf("%s\n", scale);
}
fname[0]='\0';
if ((line = get_line(stdin))==NULL) break;
/* skip empty lines, comment lines, name lines */
while (line && ((*line=='*')||(*line=='\0')||(*line=='>'))) {
printf("%s\n", line); free(line);
if ((line = get_line(stdin))==NULL) break;
}
if ((line ==NULL) || (strcmp(line, "@") == 0)) break;
s1 = (char *) space(strlen(line)+1);
(void) sscanf(line,"%s",s1); free(line);
if ((line = get_line(stdin))==NULL) break;
/* skip comment lines and get filenames */
while ((*line=='*')||(*line=='\0')||(*line=='>')) {
printf("%s\n", line); free(line);
if ((line = get_line(stdin))==NULL) break;
}
if ((line ==NULL) || (strcmp(line, "@") == 0)) break;
s2 = (char *) space(strlen(line)+1);
(void) sscanf(line,"%s",s2); free(line);
for (l = 0; l < strlen(s1); l++) {
s1[l] = toupper(s1[l]);
if (!noconv && s1[l] == 'T') s1[l] = 'U';
}
for (l = 0; l < strlen(s2); l++) {
s2[l] = toupper(s2[l]);
if (!noconv && s2[l] == 'T') s2[l] = 'U';
}
if (istty)
printf("lengths = %d,%d\n", strlen(s1), strlen(s2));
/* initialize_fold(length); */
update_fold_params();
if (delta>=0) {
duplexT *sub;
subopt = duplex_subopt(s1, s2, delta, 5);
for (sub=subopt; sub->i >0; sub++) {
print_struc(sub);
free(sub->structure);
}
free(subopt);
}
else {
mfe = duplexfold(s1, s2);
print_struc(&mfe);
free(mfe.structure);
}
(void) fflush(stdout);
(void) fflush(stdout);
free(s1); free(s2);
} while (1);
return 0;
}
void process_commandline ( int argc, char **argv )
{
extern FILE *sys_file;
int i,params;
int errorflag = 0;
/* if there are no arguments, print out a brief statement of usage
and exit. */
if ( argc < 2 )
{
fprintf( stderr ,"usage: %s options\nValid options are:\n", argv[0] );
fprintf( stderr , " ant -f parameterfile : read named parameter file\n" );
fprintf( stderr , " ant -c checkpointfile : read named checkpoint file\n" );
fprintf( stderr , " ant -d : read default parameters\n" );
exit(1);
}
for ( i = 1; i < argc; ++i )
{
/* all options begin with '-' and have two characters */
if ( argv[i][0] != '-' )
{
fprintf( stderr , "\nunrecognized command line option: \"%s\".",
argv[i] );
errorflag = 1;
continue;
}
switch ( argv[i][1] )
{
case 'f':
/* load a parameter file, named in the next argument. */
oprintf( 1,sys_file," Read parameters from input file \"%s\"\n",argv[++i]);
delay(1000);
startfromcheckpoint = 0;
read_parameter_file ( argv[2] );
break;
case 'c':
/* load a checkpoint file, named in the next argument. */
oprintf( 1,sys_file,"Read parameters from checkpoint file \"%s\"\n",argv[++i]);
read_checkpoint ( argv[2] , gene_track_array );
break;
case 'd':
/* load the default parameters. */
startfromcheckpoint = 0;
oprintf(1,sys_file," Read all default parameters.\n");
delay(1000);
return;
break;
default:
fprintf( stderr , "\nunrecognized command line option: \"%s\".",
argv[i] );
errorflag = 1;
break;
}
}
if ( errorflag )
{
fprintf( stderr , "\ncommand line errors occurred. dying." );
exit(1);
}
/*// read_checkpoint ( "ant1.ckp",&gene_track_array);
// read_parameter_file ( "input.ant");*/
return;
}
PRIVATE void command_line(int argc, char *argv[])
{
int i, sym;
char *ns_bases=NULL, *c;
char *ParamFile=NULL;
struct RNApdist_args_info args_info;
task = 'p';
/*
#############################################
# check the command line parameters
#############################################
*/
if(RNApdist_cmdline_parser (argc, argv, &args_info) != 0) exit(1);
/* temperature */
if(args_info.temp_given)
temperature = args_info.temp_arg;
/* do not take special tetra loop energies into account */
if(args_info.noTetra_given)
tetra_loop=0;
/* set dangle model */
if(args_info.dangles_given){
dangles = args_info.dangles_arg;
if(dangles) dangles = 2;
}
/* set energy model */
if(args_info.energyModel_given)
energy_set = args_info.energyModel_arg;
/* do not allow weak pairs */
if(args_info.noLP_given)
noLonelyPairs = 1;
/* do not allow wobble pairs (GU) */
if(args_info.noGU_given)
noGU = 1;
/* do not allow weak closing pairs (AU,GU) */
if(args_info.noClosingGU_given)
no_closingGU = 1;
/* do not convert DNA nucleotide "T" to appropriate RNA "U" */
if(args_info.noconv_given)
noconv = 1;
/* Allow other pairs in addition to the usual AU,GC,and GU pairs */
if(args_info.nsp_given)
ns_bases = strdup(args_info.nsp_arg);
/* take another energy parameter set */
if(args_info.paramFile_given)
ParamFile = strdup(args_info.paramFile_arg);
if(args_info.compare_given){
switch(args_info.compare_arg[0]){
case 'p':
case 'm':
case 'f':
case 'c': task=args_info.compare_arg[0];
break;
default: RNApdist_cmdline_parser_print_help();
exit(EXIT_FAILURE);
}
}
if(args_info.backtrack_given){
if(strcmp(args_info.backtrack_arg, "none")){
strncpy(outfile, args_info.backtrack_arg, FILENAME_MAX_LENGTH-1);
}
edit_backtrack = 1;
}
/* free allocated memory of command line data structure */
RNApdist_cmdline_parser_free (&args_info);
/* do some preparations */
if (ParamFile!=NULL)
read_parameter_file(ParamFile);
if (ns_bases!=NULL) {
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-') {
sym=1; c++;
}
while (*c!='\0') {
if (*c!=',') {
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1))) {
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
}
/**@brief Main routine of L-Galaxies*/
int main(int argc, char **argv)
{
int filenr, *FileToProcess, *TaskToProcess, nfiles;
char buf[1000];
time_t start, current;
//Catch floating point exceptions
#ifdef DEBUG
#endif
#ifdef PARALLEL
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &ThisTask);
MPI_Comm_size(MPI_COMM_WORLD, &NTask);
#else
NTask = 1;
ThisTask = 0;
#endif //PARALLEL
#ifdef MCMC
time(&global_starting_time);
#endif
if(argc > 3)
{
printf("\n usage: L-Galaxies <parameterfile>\n\n");
endrun(0);
}
if (ThisTask == 0)
printf("%s\n",COMPILETIMESETTINGS);
/*Reads the parameter file, given as an argument at run time. */
read_parameter_file(argv[1]);
#ifdef MR_PLUS_MRII
//Start with MR files and later change to MRII
LastDarkMatterSnapShot=LastDarkMatterSnapShot_MR;
sprintf(FileWithZList, "%s", FileWithZList_MR);
sprintf(FileWithZList_OriginalCosm, "%s", FileWithZList_OriginalCosm_MR);
#endif
mymalloc_init();
sprintf(FinalOutputDir, "%s", OutputDir);
if(argc == 3)
sprintf(OutputDir, "%s", argv[2]);
//time(&start);
/* check compatibility of some Makefile Options*/
check_options();
#ifdef COMPUTE_SPECPHOT_PROPERTIES
//for dust_model
mu_seed = -150;
#endif
init();
#ifdef STAR_FORMATION_HISTORY
#ifdef PARALLEL
if(ThisTask == 0)
#endif
write_sfh_bins();
#endif
#ifdef MCMC
#ifdef PARALLEL
/* a small delay to avoid all processors reading trees at the same time*/
time(&start);
do
time(¤t);
while(difftime(current, start) < 10.0 * ThisTask);
#endif
#endif
#ifndef MCMC
nfiles=get_nr_files_to_process(ThisTask);
FileToProcess=mymalloc("FileToProcess", sizeof(int) * nfiles);
TaskToProcess=mymalloc("TaskToProcess", sizeof(int) * nfiles);
assign_files_to_tasks(FileToProcess, TaskToProcess, ThisTask, NTask, nfiles);
int file;
for(file = 0; file < nfiles; file++)
{
if(ThisTask==TaskToProcess[file])
filenr=FileToProcess[file];
else
continue;
#else //MCMC
/* In MCMC mode only one file is loaded into memory
* and the sampling for all the steps is done on it */
sprintf(SimulationDir, "%s/MergerTrees_%d/", SimulationDir, ThisTask);
for(filenr = MCMCTreeSampleFile; filenr <= MCMCTreeSampleFile; filenr++)
{
#endif //MCMC
time(&start);
#ifdef READXFRAC
get_xfrac_mesh();
#endif
load_tree_table(filenr);
/* Read in mesh dimensions */
#ifdef MCMC
#ifdef PARALLEL
time_t start, start2;
/* a small delay to reset processors to the same time*/
time(&start2);
do
time(¤t);
while(difftime(current, start2) < 10.0 * (NTask-ThisTask));
#endif
Senna(); // run the model in MCMC MODE
#else
SAM(filenr); // run the model in NORMAL MODE
#endif
#ifdef MCMC
break; //break loop on files since the MCMC is done on a single file
#else
time(¤t);
printf("\ndone tree file %d in %ldmin and %lds\n\n", filenr, (current - start)/60, (current - start)%60);
#endif //MCMC
free_tree_table();
//if temporary directory given as argument
if(argc == 3)
{
#ifdef GALAXYTREE
sprintf(buf, "mv %s/%s_galtree_%d %s", OutputDir,FileNameGalaxies, filenr, FinalOutputDir);
#else
sprintf(buf, "mv %s/%s_z*_%d %s", OutputDir,FileNameGalaxies, filenr, FinalOutputDir);
#endif
system(buf);
}
}
#ifndef MCMC
myfree(TaskToProcess);
myfree(FileToProcess);
#endif
#ifdef PARALLEL
MPI_Barrier(MPI_COMM_WORLD);
MPI_Finalize();
#endif
return 0;
}
/**@brief SAM() loops on trees and calls construct_galaxies.*/
#ifdef MCMC
double SAM(int filenr)
#else
void SAM(int filenr)
#endif
{
int treenr, halonr;
time_t t_mark_a, t_mark_b;
#ifdef MCMC
int ii;
MCMC_GAL = mymalloc("MCMC_Gal", sizeof(struct MCMC_GALAXY) * MCMCAllocFactor);
for(ii=0;ii<NOUT;ii++)
TotMCMCGals[ii] = 0;
if(Sample_Cosmological_Parameters==1)
{
reset_cosmology ();
#ifdef HALOMODEL
initialize_halomodel();
#endif
}
#ifdef MR_PLUS_MRII
change_dark_matter_sim("MR");
#else
if(Sample_Cosmological_Parameters==1 || CurrentMCMCStep==1)
read_sample_info();
else
{
int snap, ii;
for(snap=0;snap<NOUT;snap++)
for(ii=0;ii<NFofsInSample[snap];ii++)
MCMC_FOF[ii].NGalsInFoF[snap]=0;
}
#endif
#endif
//to be used when we have tables for the scaling in any cosmology
//read_scaling_parameters();
#ifndef MCMC
#ifdef GALAXYTREE
create_galaxy_tree_file(filenr);
#else
create_galaxy_files(filenr);
#endif
#ifdef ALL_SKY_LIGHTCONE
int nr;
for ( nr = 0; nr < NCONES; nr++)
create_galaxy_lightcone_files(filenr, nr);
#endif
#endif
#ifdef GALAXYTREE
FILE *fdg = fopen("treengal.dat", "w");
#endif
//***************************************************************************************
//***************************************************************************************
//for(treenr = 0; treenr < NTrees_Switch_MR_MRII; treenr++)
//for(treenr = NTrees_Switch_MR_MRII; treenr < Ntrees; treenr++)
/* Scan through all trees snapshot by snapshot */
int snapnum;
//for(treenr = 0; treenr < NTrees_Switch_MR_MRII; treenr++)
//for(treenr = NTrees_Switch_MR_MRII; treenr < Ntrees; treenr++)
for(treenr = 0; treenr < Ntrees; treenr++)
//for(treenr = 0; treenr < 1;treenr++)
{
//printf("doing tree %d of %d\n", treenr, Ntrees);
#ifdef MR_PLUS_MRII
if(treenr == NTrees_Switch_MR_MRII)
change_dark_matter_sim("MRII");
#endif
load_tree(treenr);
#ifdef MCMC
#ifdef PRELOAD_TREES
if(Sample_Cosmological_Parameters==1 || CurrentMCMCStep==0)
#endif
#endif
scale_cosmology(TreeNHalos[treenr]);
gsl_rng_set(random_generator, filenr * 100000 + treenr);
NumMergers = 0;
NHaloGal = 0;
#ifdef GALAXYTREE
NGalTree = 0;
IndexStored = 0;
#endif
//LastSnapShotNr is the highest output snapshot
/* we process the snapshots now in temporal order
* (as a means to reduce peak memory usage) */
for(snapnum = 0; snapnum <= LastSnapShotNr; snapnum++)
//for(snapnum = 0; snapnum <= 30; snapnum++)
{
#ifdef MCMC
/* read the appropriate parameter list for current snapnum
* into the parameter variables to be used in construct_galaxies */
read_mcmc_par(snapnum);
#else
//used to allow parameter values to vary with redshift
//re_set_parameters(snapnum);
#endif
//printf("doing snap=%d\n",snapnum);
for(halonr = 0; halonr < TreeNHalos[treenr]; halonr++)
if(HaloAux[halonr].DoneFlag == 0 && Halo[halonr].SnapNum == snapnum)
construct_galaxies(filenr, treenr, halonr);
}
/* output remaining galaxies as needed */
while(NHaloGal)
output_galaxy(treenr, 0);
#ifndef MCMC
#ifdef GALAXYTREE
save_galaxy_tree_finalize(filenr, treenr);
#ifndef PARALLEL
if((treenr/100)*100==treenr) printf("treenr=%d TotGalCount=%d\n", treenr, TotGalCount);
#endif
fflush(stdout);
fprintf(fdg, "%d\n", NGalTree);
#endif
#else//ifdef MCMC
#ifdef PRELOAD_TREES
if(Sample_Cosmological_Parameters==1)
un_scale_cosmology(TreeNHalos[treenr]);
#endif
#endif
free_galaxies_and_tree();
}
#ifdef MCMC
double lhood = get_likelihood();
#ifdef MR_PLUS_MRII
free(MCMC_FOF);
#else
if(Sample_Cosmological_Parameters==1 || CurrentMCMCStep==ChainLength)
free(MCMC_FOF);
#endif
#ifdef HALOMODEL
if (Sample_Cosmological_Parameters==1) {
gsl_spline_free(FofSpline);
gsl_interp_accel_free(FofAcc);
gsl_spline_free(SigmaSpline);
gsl_interp_accel_free(SigmaAcc);
gsl_spline_free(ellipSpline);
gsl_interp_accel_free(ellipAcc);
gsl_spline_free(PowSpline);
} //if
#endif
myfree(MCMC_GAL);
return lhood;
#else //MCMC
#ifdef GALAXYTREE
close_galaxy_tree_file();
#else
close_galaxy_files();
#endif
#ifdef ALL_SKY_LIGHTCONE
for (nr = 0; nr < NCONES; nr++)
close_galaxy_lightcone_files(nr);
#endif
return;
#endif
}
int main(int argc, char *argv[])
{
char *string, *line;
char *structure=NULL, *cstruc=NULL;
char fname[13], ffname[20], gfname[20];
char *ParamFile=NULL;
char *ns_bases=NULL, *c;
int i, length, l, sym, r;
double energy, min_en;
double kT, sfact=1.07;
int pf=0, noPS=0, istty;
int noconv=0;
int circ=0;
do_backtrack = 1;
string=NULL;
for (i=1; i<argc; i++) {
if (argv[i][0]=='-')
switch ( argv[i][1] )
{
case 'T': if (argv[i][2]!='\0') usage();
if(i==argc-1) usage();
r=sscanf(argv[++i], "%lf", &temperature);
if (!r) usage();
break;
case 'p': pf=1;
if (argv[i][2]!='\0')
(void) sscanf(argv[i]+2, "%d", &do_backtrack);
break;
case 'n':
if ( strcmp(argv[i], "-noGU")==0) noGU=1;
if ( strcmp(argv[i], "-noCloseGU")==0) no_closingGU=1;
if ( strcmp(argv[i], "-noLP")==0) noLonelyPairs=1;
if ( strcmp(argv[i], "-noPS")==0) noPS=1;
if ( strcmp(argv[i], "-nsp") ==0) {
if (i==argc-1) usage();
ns_bases = argv[++i];
}
if ( strcmp(argv[i], "-noconv")==0) noconv=1;
break;
case '4':
tetra_loop=0;
break;
case 'e':
if(i==argc-1) usage();
r=sscanf(argv[++i],"%d", &energy_set);
if (!r) usage();
break;
case 'C':
fold_constrained=1;
break;
case 'c':
if ( strcmp(argv[i], "-circ")==0) circ=1;
break;
case 'S':
if(i==argc-1) usage();
r=sscanf(argv[++i],"%lf", &sfact);
if (!r) usage();
break;
case 'd': dangles=0;
if (argv[i][2]!='\0') {
r=sscanf(argv[i]+2, "%d", &dangles);
if (r!=1) usage();
}
break;
case 'P':
if (i==argc-1) usage();
ParamFile = argv[++i];
break;
default: usage();
}
}
if (circ && noLonelyPairs)
fprintf(stderr, "warning, depending on the origin of the circular sequence, some structures may be missed when using -noLP\nTry rotating your sequence a few times\n");
if (ParamFile != NULL)
read_parameter_file(ParamFile);
if (ns_bases != NULL) {
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-') {
sym=1; c++;
}
while (*c!='\0') {
if (*c!=',') {
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1))) {
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
istty = isatty(fileno(stdout))&&isatty(fileno(stdin));
if ((fold_constrained)&&(istty)) {
printf("Input constraints using the following notation:\n");
printf("| : paired with another base\n");
printf(". : no constraint at all\n");
printf("x : base must not pair\n");
printf("< : base i is paired with a base j<i\n");
printf("> : base i is paired with a base j>i\n");
printf("matching brackets ( ): base i pairs base j\n");
}
do { /* main loop: continue until end of file */
if (istty) {
printf("\nInput string (upper or lower case); @ to quit\n");
printf("%s%s\n", scale1, scale2);
}
fname[0]='\0';
if ((line = get_line(stdin))==NULL) break;
/* skip comment lines and get filenames */
while ((*line=='*')||(*line=='\0')||(*line=='>')) {
if (*line=='>')
(void) sscanf(line, ">%12s", fname);
printf("%s\n", line);
free(line);
if ((line = get_line(stdin))==NULL) break;
}
if ((line ==NULL) || (strcmp(line, "@") == 0)) break;
string = (char *) space(strlen(line)+1);
(void) sscanf(line,"%s",string);
free(line);
length = (int) strlen(string);
structure = (char *) space((unsigned) length+1);
if (fold_constrained) {
cstruc = get_line(stdin);
if (cstruc!=NULL)
strncpy(structure, cstruc, length);
else
fprintf(stderr, "constraints missing\n");
}
for (l = 0; l < length; l++) {
string[l] = toupper(string[l]);
if (!noconv && string[l] == 'T') string[l] = 'U';
}
if (istty)
printf("length = %d\n", length);
/* initialize_fold(length); */
if (circ)
min_en = circfold(string, structure);
else
min_en = fold(string, structure);
printf("%s\n%s", string, structure);
if (istty)
printf("\n minimum free energy = %6.2f kcal/mol\n", min_en);
else
printf(" (%6.2f)\n", min_en);
(void) fflush(stdout);
if (fname[0]!='\0') {
strcpy(ffname, fname);
strcat(ffname, "_ss.ps");
strcpy(gfname, fname);
strcat(gfname, "_ss.g");
} else {
strcpy(ffname, "rna.ps");
strcpy(gfname, "rna.g");
}
if (!noPS) {
if (length<2000)
(void) PS_rna_plot(string, structure, ffname);
else
fprintf(stderr,"INFO: structure too long, not doing xy_plot\n");
}
if (length>2000) free_arrays();
if (pf) {
char *pf_struc;
pf_struc = (char *) space((unsigned) length+1);
if (dangles==1) {
dangles=2; /* recompute with dangles as in pf_fold() */
min_en = (circ) ? energy_of_circ_struct(string, structure) : energy_of_struct(string, structure);
dangles=1;
}
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(sfact*min_en)/kT/length);
if (length>2000) fprintf(stderr, "scaling factor %f\n", pf_scale);
(circ) ? init_pf_circ_fold(length) : init_pf_fold(length);
if (cstruc!=NULL)
strncpy(pf_struc, cstruc, length+1);
energy = (circ) ? pf_circ_fold(string, pf_struc) : pf_fold(string, pf_struc);
if (do_backtrack) {
printf("%s", pf_struc);
if (!istty) printf(" [%6.2f]\n", energy);
else printf("\n");
}
if ((istty)||(!do_backtrack))
printf(" free energy of ensemble = %6.2f kcal/mol\n", energy);
if (do_backtrack) {
plist *pl1,*pl2;
char *cent;
double dist, cent_en;
cent = centroid(length, &dist);
cent_en = (circ) ? energy_of_circ_struct(string, cent) :energy_of_struct(string, cent);
printf("%s {%6.2f d=%.2f}\n", cent, cent_en, dist);
free(cent);
if (fname[0]!='\0') {
strcpy(ffname, fname);
strcat(ffname, "_dp.ps");
} else strcpy(ffname, "dot.ps");
pl1 = make_plist(length, 1e-5);
pl2 = b2plist(structure);
(void) PS_dot_plot_list(string, ffname, pl1, pl2, "");
free(pl2);
if (do_backtrack==2) {
pl2 = stackProb(1e-5);
if (fname[0]!='\0') {
strcpy(ffname, fname);
strcat(ffname, "_dp2.ps");
} else strcpy(ffname, "dot2.ps");
PS_dot_plot_list(string, ffname, pl1, pl2,
"Probabilities for stacked pairs (i,j)(i+1,j-1)");
free(pl2);
}
free(pl1);
free(pf_struc);
}
printf(" frequency of mfe structure in ensemble %g; ",
exp((energy-min_en)/kT));
if (do_backtrack)
printf("ensemble diversity %-6.2f", mean_bp_dist(length));
printf("\n");
free_pf_arrays();
}
if (cstruc!=NULL) free(cstruc);
(void) fflush(stdout);
free(string);
free(structure);
} while (1);
return 0;
}
int main(int argc, char *argv[]){
struct RNAheat_args_info args_info;
char *string, *input_string, *ns_bases, *c, *ParamFile, *rec_sequence, *rec_id, **rec_rest, *orig_sequence;
int i, length, l, sym;
float T_min, T_max, h;
int mpoints, istty, noconv = 0;
unsigned int input_type;
unsigned int rec_type, read_opt;
string = ParamFile = ns_bases = NULL;
T_min = 0.;
T_max = 100.;
h = 1;
mpoints = 2;
dangles = 2; /* dangles can be 0 (no dangles) or 2, default is 2 */
rec_type = read_opt = 0;
rec_id = rec_sequence = orig_sequence = NULL;
rec_rest = NULL;
/*
#############################################
# check the command line parameters
#############################################
*/
if(RNAheat_cmdline_parser(argc, argv, &args_info) != 0) exit(1);
/* do not take special tetra loop energies into account */
if(args_info.noTetra_given) tetra_loop=0;
/* set dangle model */
if(args_info.dangles_given){
if((args_info.dangles_arg != 0) && (args_info.dangles_arg != 2))
vrna_message_warning("required dangle model not implemented, falling back to default dangles=2");
else
dangles = args_info.dangles_arg;
}
/* do not allow weak pairs */
if(args_info.noLP_given) noLonelyPairs = 1;
/* do not allow wobble pairs (GU) */
if(args_info.noGU_given) noGU = 1;
/* do not allow weak closing pairs (AU,GU) */
if(args_info.noClosingGU_given) no_closingGU = 1;
/* do not convert DNA nucleotide "T" to appropriate RNA "U" */
if(args_info.noconv_given) noconv = 1;
/* set energy model */
if(args_info.energyModel_given) energy_set = args_info.energyModel_arg;
/* take another energy parameter set */
if(args_info.paramFile_given) ParamFile = strdup(args_info.paramFile_arg);
/* Allow other pairs in addition to the usual AU,GC,and GU pairs */
if(args_info.nsp_given) ns_bases = strdup(args_info.nsp_arg);
/* Tmin */
if(args_info.Tmin_given) T_min = args_info.Tmin_arg;
/* Tmax */
if(args_info.Tmax_given) T_max = args_info.Tmax_arg;
/* step size */
if(args_info.stepsize_given) h = args_info.stepsize_arg;
/* ipoints */
if(args_info.ipoints_given){
mpoints = args_info.ipoints_arg;
if (mpoints < 1) mpoints = 1;
if (mpoints > 100) mpoints = 100;
}
/* free allocated memory of command line data structure */
RNAheat_cmdline_parser_free (&args_info);
/*
#############################################
# begin initializing
#############################################
*/
if (ParamFile!=NULL) read_parameter_file(ParamFile);
if (ns_bases != NULL) {
nonstandards = vrna_alloc(33);
c=ns_bases;
i=sym=0;
if (*c=='-') {
sym=1; c++;
}
while (*c!='\0') {
if (*c!=',') {
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1))) {
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
istty = isatty(fileno(stdout))&&isatty(fileno(stdin));
read_opt |= VRNA_INPUT_NO_REST;
if(istty){
vrna_message_input_seq_simple();
read_opt |= VRNA_INPUT_NOSKIP_BLANK_LINES;
}
/*
#############################################
# main loop: continue until end of file
#############################################
*/
while(
!((rec_type = vrna_file_fasta_read_record(&rec_id, &rec_sequence, &rec_rest, NULL, read_opt))
& (VRNA_INPUT_ERROR | VRNA_INPUT_QUIT))){
/*
########################################################
# init everything according to the data we've read
########################################################
*/
if(rec_id && !istty) printf("%s\n", rec_id);
length = (int)strlen(rec_sequence);
/* convert DNA alphabet to RNA if not explicitely switched off */
if(!noconv) vrna_seq_toRNA(rec_sequence);
/* store case-unmodified sequence */
orig_sequence = strdup(rec_sequence);
/* convert sequence to uppercase letters only */
vrna_seq_toupper(rec_sequence);
if(istty) printf("length = %d\n", length);
/*
########################################################
# done with 'stdin' handling
########################################################
*/
heat_capacity(rec_sequence, T_min, T_max, h, mpoints);
(void) fflush(stdout);
/* clean up */
if(rec_id) free(rec_id);
free(rec_sequence);
free(orig_sequence);
rec_id = rec_sequence = orig_sequence = NULL;
rec_rest = NULL;
/* print user help for the next round if we get input from tty */
if(istty) vrna_message_input_seq_simple();
}
return EXIT_SUCCESS;
}
void load_fold_params( char* filename ) {
read_parameter_file( filename );
}
int main(int argc, char *argv[]){
struct RNALalifold_args_info args_info;
char *string, *structure, *ParamFile, *ns_bases, *c;
char ffname[80], gfname[80], fname[80];
int n_seq, i, length, sym, r, maxdist;
int mis, pf, istty;
float cutoff;
double min_en, real_en, sfact;
char *AS[MAX_NUM_NAMES]; /* aligned sequences */
char *names[MAX_NUM_NAMES]; /* sequence names */
FILE *clust_file = stdin;
string = structure = ParamFile = ns_bases = NULL;
mis = pf = 0;
maxdist = 70;
do_backtrack = 1;
dangles = 2;
sfact = 1.07;
cutoff = 0.0005;
/*
#############################################
# check the command line parameters
#############################################
*/
if(RNALalifold_cmdline_parser (argc, argv, &args_info) != 0) exit(1);
/* temperature */
if(args_info.temp_given) temperature = args_info.temp_arg;
/* structure constraint */
if(args_info.noTetra_given) tetra_loop=0;
/* set dangle model */
if(args_info.dangles_given) dangles = args_info.dangles_arg;
/* do not allow weak pairs */
if(args_info.noLP_given) noLonelyPairs = 1;
/* do not allow wobble pairs (GU) */
if(args_info.noGU_given) noGU = 1;
/* do not allow weak closing pairs (AU,GU) */
if(args_info.noClosingGU_given) no_closingGU = 1;
/* set energy model */
if(args_info.energyModel_given) energy_set = args_info.energyModel_arg;
/* take another energy parameter set */
if(args_info.paramFile_given) ParamFile = strdup(args_info.paramFile_arg);
/* Allow other pairs in addition to the usual AU,GC,and GU pairs */
if(args_info.nsp_given) ns_bases = strdup(args_info.nsp_arg);
/* set pf scaling factor */
if(args_info.pfScale_given) sfact = args_info.pfScale_arg;
/* partition function settings */
if(args_info.partfunc_given){
pf = 1;
if(args_info.partfunc_arg != -1)
do_backtrack = args_info.partfunc_arg;
}
/* set cfactor */
if(args_info.cfactor_given) cv_fact = args_info.cfactor_arg;
/* set nfactor */
if(args_info.nfactor_given) nc_fact = args_info.nfactor_arg;
/* set the maximum base pair span */
if(args_info.span_given) maxdist = args_info.span_arg;
/* set the pair probability cutoff */
if(args_info.cutoff_given) cutoff = args_info.cutoff_arg;
/* calculate most informative sequence */
if(args_info.mis_given) mis = 1;
/* check unnamed options a.k.a. filename of input alignment */
if(args_info.inputs_num == 1){
clust_file = fopen(args_info.inputs[0], "r");
if(clust_file == NULL){
fprintf(stderr, "can't open %s\n", args_info.inputs[0]);
}
}
else{
RNALalifold_cmdline_parser_print_help();
exit(1);
}
/* free allocated memory of command line data structure */
RNALalifold_cmdline_parser_free (&args_info);
/*
#############################################
# begin initializing
#############################################
*/
if (ParamFile != NULL)
read_parameter_file(ParamFile);
if (ns_bases != NULL) {
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-') {
sym=1; c++;
}
while (*c!='\0') {
if (*c!=',') {
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1))) {
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
istty = isatty(fileno(stdout))&&isatty(fileno(stdin));
if (istty && (clust_file == stdin)) {
print_tty_input_seq_str("Input aligned sequences in clustalw format");
}
n_seq = read_clustal(clust_file, AS, names);
if (clust_file != stdin) fclose(clust_file);
if (n_seq==0)
nrerror("no sequences found");
length = (int) strlen(AS[0]);
if (length<maxdist) {
fprintf(stderr, "Alignment length < window size: setting L=%d\n",length);
maxdist=length;
}
structure = (char *) space((unsigned) length+1);
/*
#############################################
# begin calculations
#############################################
*/
update_fold_params();
if(!pf)
min_en = aliLfold(AS, structure, maxdist);
{
eos_debug=-1; /* shut off warnings about nonstandard pairs */
/* for (i=0; AS[i]!=NULL; i++)
s += energy_of_struct(AS[i], structure);
real_en = s/i;*/
}
string = (mis) ? consens_mis((const char **) AS) : consensus((const char **) AS);
printf("%s\n%s\n", string, structure);
/* if (istty)
printf("\n minimum free energy = %6.2f kcal/mol (%6.2f + %6.2f)\n",
min_en, real_en, min_en - real_en);
else
printf(" (%6.2f = %6.2f + %6.2f) \n", min_en, real_en, min_en-real_en );
*/
strcpy(ffname, "alirna.ps");
strcpy(gfname, "alirna.g");
/* if (length<=2500) {
char *A;
A = annote(structure, (const char**) AS);
(void) PS_rna_plot_a(string, structure, ffname, NULL, A);
free(A);
} else
fprintf(stderr,"INFO: structure too long, not doing xy_plot\n");
*/
/* {*/ /* free mfe arrays but preserve base_pair for PS_dot_plot */
/* struct bond *bp;
bp = base_pair; base_pair = space(16);
free_alifold_arrays(); / * frees base_pair * /
base_pair = bp;
}*/
if (pf) {
double energy, kT;
plist *pl;
char * mfe_struc;
mfe_struc = strdup(structure);
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = -1;/*exp(-(sfact*min_en)/kT/length);*/
if (length>2000) fprintf(stderr, "scaling factor %f\n", pf_scale);
fflush(stdout);
/* init_alipf_fold(length); */
/* energy = alipfW_fold(AS, structure, &pl, maxdist, cutoff); */
if (do_backtrack) {
printf("%s", structure);
/*if (!istty) printf(" [%6.2f]\n", energy);
else */
printf("\n");
}
/*if ((istty)||(!do_backtrack))
printf(" free energy of ensemble = %6.2f kcal/mol\n", energy);
useless!!*/
/* printf(" frequency of mfe structure in ensemble %g\n",
exp((energy-min_en)/kT));*/
if (do_backtrack) {
FILE *aliout;
cpair *cp;
strcpy(ffname, "alifold.out");
aliout = fopen(ffname, "w");
if (!aliout) {
fprintf(stderr, "can't open %s skipping output\n", ffname);
} else {
fprintf(aliout, "%d sequence; length of alignment %d\n",
n_seq, length);
fprintf(aliout, "alifold output\n");
fprintf(aliout, "%s\n", structure);
}
strcpy(ffname, "alidotL.ps");
cp = make_color_pinfo2(AS,pl,n_seq);
(void) PS_color_dot_plot_turn(string, cp, ffname, maxdist);
free(cp);
}
free(mfe_struc);
free(pl);
}
free(base_pair);
(void) fflush(stdout);
free(string);
free(structure);
for (i=0; AS[i]; i++) {
free(AS[i]); free(names[i]);
}
return 0;
}
int main(int argc, char *argv[])
{
struct RNAcofold_args_info args_info;
unsigned int input_type;
char *string, *input_string;
char *structure, *cstruc, *rec_sequence, *orig_sequence, *rec_id, **rec_rest;
char fname[FILENAME_MAX_LENGTH], ffname[FILENAME_MAX_LENGTH];
char *ParamFile;
char *ns_bases, *c;
char *Concfile;
int i, length, l, sym, r, cl;
double min_en;
double kT, sfact, betaScale;
int pf, istty;
int noconv, noPS;
int doT; /*compute dimere free energies etc.*/
int doC; /*toggle to compute concentrations*/
int doQ; /*toggle to compute prob of base being paired*/
int cofi; /*toggle concentrations stdin / file*/
plist *prAB;
plist *prAA; /*pair probabilities of AA dimer*/
plist *prBB;
plist *prA;
plist *prB;
plist *mfAB;
plist *mfAA; /*pair mfobabilities of AA dimer*/
plist *mfBB;
plist *mfA;
plist *mfB;
double *ConcAandB;
unsigned int rec_type, read_opt;
pf_paramT *pf_parameters;
model_detailsT md;
/*
#############################################
# init variables and parameter options
#############################################
*/
dangles = 2;
sfact = 1.07;
bppmThreshold = 1e-5;
noconv = 0;
noPS = 0;
do_backtrack = 1;
pf = 0;
doT = 0;
doC = 0;
doQ = 0;
cofi = 0;
betaScale = 1.;
gquad = 0;
ParamFile = NULL;
pf_parameters = NULL;
string = NULL;
Concfile = NULL;
structure = NULL;
cstruc = NULL;
ns_bases = NULL;
rec_type = read_opt = 0;
rec_id = rec_sequence = orig_sequence = NULL;
rec_rest = NULL;
set_model_details(&md);
/*
#############################################
# check the command line prameters
#############################################
*/
if(RNAcofold_cmdline_parser (argc, argv, &args_info) != 0) exit(1);
/* temperature */
if(args_info.temp_given) temperature = args_info.temp_arg;
/* structure constraint */
if(args_info.constraint_given) fold_constrained=1;
/* do not take special tetra loop energies into account */
if(args_info.noTetra_given) md.special_hp = tetra_loop=0;
/* set dangle model */
if(args_info.dangles_given){
if((args_info.dangles_arg < 0) || (args_info.dangles_arg > 3))
warn_user("required dangle model not implemented, falling back to default dangles=2");
else
md.dangles = dangles = args_info.dangles_arg;
}
/* do not allow weak pairs */
if(args_info.noLP_given) md.noLP = noLonelyPairs = 1;
/* do not allow wobble pairs (GU) */
if(args_info.noGU_given) md.noGU = noGU = 1;
/* do not allow weak closing pairs (AU,GU) */
if(args_info.noClosingGU_given) md.noGUclosure = no_closingGU = 1;
/* gquadruplex support */
if(args_info.gquad_given) md.gquad = gquad = 1;
/* enforce canonical base pairs in any case? */
if(args_info.canonicalBPonly_given) md.canonicalBPonly = canonicalBPonly = 1;
/* do not convert DNA nucleotide "T" to appropriate RNA "U" */
if(args_info.noconv_given) noconv = 1;
/* set energy model */
if(args_info.energyModel_given) energy_set = args_info.energyModel_arg;
/* */
if(args_info.noPS_given) noPS = 1;
/* take another energy parameter set */
if(args_info.paramFile_given) ParamFile = strdup(args_info.paramFile_arg);
/* Allow other pairs in addition to the usual AU,GC,and GU pairs */
if(args_info.nsp_given) ns_bases = strdup(args_info.nsp_arg);
/* set pf scaling factor */
if(args_info.pfScale_given) sfact = args_info.pfScale_arg;
if(args_info.all_pf_given) doT = pf = 1;
/* concentrations from stdin */
if(args_info.concentrations_given) doC = doT = pf = 1;
/* set the bppm threshold for the dotplot */
if(args_info.bppmThreshold_given)
bppmThreshold = MIN2(1., MAX2(0.,args_info.bppmThreshold_arg));
/* concentrations in file */
if(args_info.betaScale_given) betaScale = args_info.betaScale_arg;
if(args_info.concfile_given){
Concfile = strdup(args_info.concfile_arg);
doC = cofi = doT = pf = 1;
}
/* partition function settings */
if(args_info.partfunc_given){
pf = 1;
if(args_info.partfunc_arg != -1)
do_backtrack = args_info.partfunc_arg;
}
/* free allocated memory of command line data structure */
RNAcofold_cmdline_parser_free (&args_info);
/*
#############################################
# begin initializing
#############################################
*/
if(pf && gquad){
nrerror("G-Quadruplex support is currently not available for partition function computations");
}
if (ParamFile != NULL)
read_parameter_file(ParamFile);
if (ns_bases != NULL) {
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-') {
sym=1; c++;
}
while (*c!='\0') {
if (*c!=',') {
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1))) {
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
istty = isatty(fileno(stdout))&&isatty(fileno(stdin));
/* print user help if we get input from tty */
if(istty){
printf("Use '&' to connect 2 sequences that shall form a complex.\n");
if(fold_constrained){
print_tty_constraint(VRNA_CONSTRAINT_DOT | VRNA_CONSTRAINT_X | VRNA_CONSTRAINT_ANG_BRACK | VRNA_CONSTRAINT_RND_BRACK);
print_tty_input_seq_str("Input sequence (upper or lower case) followed by structure constraint\n");
}
else print_tty_input_seq();
}
/* set options we wanna pass to read_record */
if(istty) read_opt |= VRNA_INPUT_NOSKIP_BLANK_LINES;
if(!fold_constrained) read_opt |= VRNA_INPUT_NO_REST;
/*
#############################################
# main loop: continue until end of file
#############################################
*/
while(
!((rec_type = read_record(&rec_id, &rec_sequence, &rec_rest, read_opt))
& (VRNA_INPUT_ERROR | VRNA_INPUT_QUIT))){
/*
########################################################
# init everything according to the data we've read
########################################################
*/
if(rec_id){
if(!istty) printf("%s\n", rec_id);
(void) sscanf(rec_id, ">%" XSTR(FILENAME_ID_LENGTH) "s", fname);
}
else fname[0] = '\0';
cut_point = -1;
rec_sequence = tokenize(rec_sequence); /* frees input_string and sets cut_point */
length = (int) strlen(rec_sequence);
structure = (char *) space((unsigned) length+1);
/* parse the rest of the current dataset to obtain a structure constraint */
if(fold_constrained){
cstruc = NULL;
int cp = cut_point;
unsigned int coptions = (rec_id) ? VRNA_CONSTRAINT_MULTILINE : 0;
coptions |= VRNA_CONSTRAINT_DOT | VRNA_CONSTRAINT_X | VRNA_CONSTRAINT_ANG_BRACK | VRNA_CONSTRAINT_RND_BRACK;
getConstraint(&cstruc, (const char **)rec_rest, coptions);
cstruc = tokenize(cstruc);
if(cut_point != cp) nrerror("cut point in sequence and structure constraint differs");
cl = (cstruc) ? (int)strlen(cstruc) : 0;
if(cl == 0) warn_user("structure constraint is missing");
else if(cl < length) warn_user("structure constraint is shorter than sequence");
else if(cl > length) nrerror("structure constraint is too long");
if(cstruc) strncpy(structure, cstruc, sizeof(char)*(cl+1));
}
/* convert DNA alphabet to RNA if not explicitely switched off */
if(!noconv) str_DNA2RNA(rec_sequence);
/* store case-unmodified sequence */
orig_sequence = strdup(rec_sequence);
/* convert sequence to uppercase letters only */
str_uppercase(rec_sequence);
if(istty){
if (cut_point == -1)
printf("length = %d\n", length);
else
printf("length1 = %d\nlength2 = %d\n", cut_point-1, length-cut_point+1);
}
/*
########################################################
# begin actual computations
########################################################
*/
if (doC) {
FILE *fp;
if (cofi) { /* read from file */
fp = fopen(Concfile, "r");
if (fp==NULL) {
fprintf(stderr, "could not open concentration file %s", Concfile);
nrerror("\n");
}
ConcAandB = read_concentrations(fp);
fclose(fp);
} else {
printf("Please enter concentrations [mol/l]\n format: ConcA ConcB\n return to end\n");
ConcAandB = read_concentrations(stdin);
}
}
/*compute mfe of AB dimer*/
min_en = cofold(rec_sequence, structure);
assign_plist_from_db(&mfAB, structure, 0.95);
{
char *pstring, *pstruct;
if (cut_point == -1) {
pstring = strdup(orig_sequence);
pstruct = strdup(structure);
} else {
pstring = costring(orig_sequence);
pstruct = costring(structure);
}
printf("%s\n%s", pstring, pstruct);
if (istty)
printf("\n minimum free energy = %6.2f kcal/mol\n", min_en);
else
printf(" (%6.2f)\n", min_en);
(void) fflush(stdout);
if (!noPS) {
char annot[512] = "";
if (fname[0]!='\0') {
strcpy(ffname, fname);
strcat(ffname, "_ss.ps");
} else {
strcpy(ffname, "rna.ps");
}
if (cut_point >= 0)
sprintf(annot,
"1 %d 9 0 0.9 0.2 omark\n%d %d 9 1 0.1 0.2 omark\n",
cut_point-1, cut_point+1, length+1);
if(gquad){
if (!noPS) (void) PS_rna_plot_a_gquad(pstring, pstruct, ffname, annot, NULL);
} else {
if (!noPS) (void) PS_rna_plot_a(pstring, pstruct, ffname, annot, NULL);
}
}
free(pstring);
free(pstruct);
}
if (length>2000) free_co_arrays();
/*compute partition function*/
if (pf) {
cofoldF AB, AA, BB;
FLT_OR_DBL *probs;
if (dangles==1) {
dangles=2; /* recompute with dangles as in pf_fold() */
min_en = energy_of_structure(rec_sequence, structure, 0);
dangles=1;
}
kT = (betaScale*((temperature+K0)*GASCONST))/1000.; /* in Kcal */
pf_scale = exp(-(sfact*min_en)/kT/length);
if (length>2000) fprintf(stderr, "scaling factor %f\n", pf_scale);
pf_parameters = get_boltzmann_factors(temperature, betaScale, md, pf_scale);
if (cstruc!=NULL)
strncpy(structure, cstruc, length+1);
AB = co_pf_fold_par(rec_sequence, structure, pf_parameters, do_backtrack, fold_constrained);
if (do_backtrack) {
char *costruc;
costruc = (char *) space(sizeof(char)*(strlen(structure)+2));
if (cut_point<0) printf("%s", structure);
else {
strncpy(costruc, structure, cut_point-1);
strcat(costruc, "&");
strcat(costruc, structure+cut_point-1);
printf("%s", costruc);
}
if (!istty) printf(" [%6.2f]\n", AB.FAB);
else printf("\n");/*8.6.04*/
}
if ((istty)||(!do_backtrack))
printf(" free energy of ensemble = %6.2f kcal/mol\n", AB.FAB);
printf(" frequency of mfe structure in ensemble %g",
exp((AB.FAB-min_en)/kT));
printf(" , delta G binding=%6.2f\n", AB.FcAB - AB.FA - AB.FB);
probs = export_co_bppm();
assign_plist_from_pr(&prAB, probs, length, bppmThreshold);
/* if (doQ) make_probsum(length,fname); */ /*compute prob of base paired*/
/* free_co_arrays(); */
if (doT) { /* cofold of all dimers, monomers */
int Blength, Alength;
char *Astring, *Bstring, *orig_Astring, *orig_Bstring;
char *Newstring;
char Newname[30];
char comment[80];
if (cut_point<0) {
printf("Sorry, i cannot do that with only one molecule, please give me two or leave it\n");
free(mfAB);
free(prAB);
continue;
}
if (dangles==1) dangles=2;
Alength=cut_point-1; /*length of first molecule*/
Blength=length-cut_point+1; /*length of 2nd molecule*/
Astring=(char *)space(sizeof(char)*(Alength+1));/*Sequence of first molecule*/
Bstring=(char *)space(sizeof(char)*(Blength+1));/*Sequence of second molecule*/
strncat(Astring,rec_sequence,Alength);
strncat(Bstring,rec_sequence+Alength,Blength);
orig_Astring=(char *)space(sizeof(char)*(Alength+1));/*Sequence of first molecule*/
orig_Bstring=(char *)space(sizeof(char)*(Blength+1));/*Sequence of second molecule*/
strncat(orig_Astring,orig_sequence,Alength);
strncat(orig_Bstring,orig_sequence+Alength,Blength);
/* compute AA dimer */
AA=do_partfunc(Astring, Alength, 2, &prAA, &mfAA, pf_parameters);
/* compute BB dimer */
BB=do_partfunc(Bstring, Blength, 2, &prBB, &mfBB, pf_parameters);
/*free_co_pf_arrays();*/
/* compute A monomer */
do_partfunc(Astring, Alength, 1, &prA, &mfA, pf_parameters);
/* compute B monomer */
do_partfunc(Bstring, Blength, 1, &prB, &mfB, pf_parameters);
compute_probabilities(AB.F0AB, AB.FA, AB.FB, prAB, prA, prB, Alength);
compute_probabilities(AA.F0AB, AA.FA, AA.FA, prAA, prA, prA, Alength);
compute_probabilities(BB.F0AB, BB.FA, BB.FA, prBB, prA, prB, Blength);
printf("Free Energies:\nAB\t\tAA\t\tBB\t\tA\t\tB\n%.6f\t%6f\t%6f\t%6f\t%6f\n",
AB.FcAB, AA.FcAB, BB.FcAB, AB.FA, AB.FB);
if (doC) {
do_concentrations(AB.FcAB, AA.FcAB, BB.FcAB, AB.FA, AB.FB, ConcAandB);
free(ConcAandB);/*freeen*/
}
if (fname[0]!='\0') {
strcpy(ffname, fname);
strcat(ffname, "_dp5.ps");
} else strcpy(ffname, "dot5.ps");
/*output of the 5 dot plots*/
/*AB dot_plot*/
/*write Free Energy into comment*/
sprintf(comment,"\n%%Heterodimer AB FreeEnergy= %.9f\n", AB.FcAB);
/*reset cut_point*/
cut_point=Alength+1;
/*write New name*/
strcpy(Newname,"AB");
strcat(Newname,ffname);
(void)PS_dot_plot_list(orig_sequence, Newname, prAB, mfAB, comment);
/*AA dot_plot*/
sprintf(comment,"\n%%Homodimer AA FreeEnergy= %.9f\n",AA.FcAB);
/*write New name*/
strcpy(Newname,"AA");
strcat(Newname,ffname);
/*write AA sequence*/
Newstring=(char*)space((2*Alength+1)*sizeof(char));
strcpy(Newstring,orig_Astring);
strcat(Newstring,orig_Astring);
(void)PS_dot_plot_list(Newstring, Newname, prAA, mfAA, comment);
free(Newstring);
/*BB dot_plot*/
sprintf(comment,"\n%%Homodimer BB FreeEnergy= %.9f\n",BB.FcAB);
/*write New name*/
strcpy(Newname,"BB");
strcat(Newname,ffname);
/*write BB sequence*/
Newstring=(char*)space((2*Blength+1)*sizeof(char));
strcpy(Newstring,orig_Bstring);
strcat(Newstring,orig_Bstring);
/*reset cut_point*/
cut_point=Blength+1;
(void)PS_dot_plot_list(Newstring, Newname, prBB, mfBB, comment);
free(Newstring);
/*A dot plot*/
/*reset cut_point*/
cut_point=-1;
sprintf(comment,"\n%%Monomer A FreeEnergy= %.9f\n",AB.FA);
/*write New name*/
strcpy(Newname,"A");
strcat(Newname,ffname);
/*write BB sequence*/
(void)PS_dot_plot_list(orig_Astring, Newname, prA, mfA, comment);
/*B monomer dot plot*/
sprintf(comment,"\n%%Monomer B FreeEnergy= %.9f\n",AB.FB);
/*write New name*/
strcpy(Newname,"B");
strcat(Newname,ffname);
/*write BB sequence*/
(void)PS_dot_plot_list(orig_Bstring, Newname, prB, mfB, comment);
free(Astring); free(Bstring); free(orig_Astring); free(orig_Bstring);
free(prAB); free(prAA); free(prBB); free(prA); free(prB);
free(mfAB); free(mfAA); free(mfBB); free(mfA); free(mfB);
} /*end if(doT)*/
free(pf_parameters);
}/*end if(pf)*/
if (do_backtrack) {
if (fname[0]!='\0') {
strcpy(ffname, fname);
strcat(ffname, "_dp.ps");
} else strcpy(ffname, "dot.ps");
if (!doT) {
if (pf) { (void) PS_dot_plot_list(rec_sequence, ffname, prAB, mfAB, "doof");
free(prAB);}
free(mfAB);
}
}
if (!doT) free_co_pf_arrays();
(void) fflush(stdout);
/* clean up */
if(cstruc) free(cstruc);
if(rec_id) free(rec_id);
free(rec_sequence);
free(orig_sequence);
free(structure);
/* free the rest of current dataset */
if(rec_rest){
for(i=0;rec_rest[i];i++) free(rec_rest[i]);
free(rec_rest);
}
rec_id = rec_sequence = orig_sequence = structure = cstruc = NULL;
rec_rest = NULL;
/* print user help for the next round if we get input from tty */
if(istty){
printf("Use '&' to connect 2 sequences that shall form a complex.\n");
if(fold_constrained){
print_tty_constraint(VRNA_CONSTRAINT_DOT | VRNA_CONSTRAINT_X | VRNA_CONSTRAINT_ANG_BRACK | VRNA_CONSTRAINT_RND_BRACK);
print_tty_input_seq_str("Input sequence (upper or lower case) followed by structure constraint\n");
}
else print_tty_input_seq();
}
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
struct RNAfold_args_info args_info;
char *string, *input_string, *structure=NULL, *cstruc=NULL;
char fname[80], ffname[80], gfname[80], *ParamFile=NULL;
char *ns_bases=NULL, *c;
int i, j, ii, jj, mu, length, l, sym, r, pf=0, noconv=0;
unsigned int input_type;
double energy, min_en, kT, sfact=1.07;
int doMEA=0, circular = 0, N;
char *pf_struc;
double dist;
plist *pl;
FILE * filehandle;
FILE * statsfile;
char* line;
double tau = 0.01; /* Variance of energy parameters */
double sigma = 0.01; /* Variance of experimental constraints */
double *gradient; /* Gradient for steepest descent search
epsilon[i+1]= epsilon[i] - gradient *
step_size */
double initial_step_size = 0.5; /* Initial step size for steepest
descent search */
double step_size;
double D; /* Discrepancy (i.e. value of objective
function) for the current
prediction */
int iteration, max_iteration = 2000; /* Current and maximum number of
iterations after which
algorithm stops */
double precision = 0.1; /* cutoff used for stop conditions */
double tolerance = 0.1; /* Parameter used by various GSL minimizers */
int method_id = 1; /* Method to use for minimization, 0 and 1
are custom steepest descent, the rest
are GSL implementations (see below)*/
int initial_guess_method = 0;
int sample_N = 1000;
double *prev_epsilon;
double *prev_gradient;
double DD, prev_D, sum, norm;
int status;
double* gradient_numeric;
double* gradient_numeric_gsl;
/* Minimizer vars */
const gsl_multimin_fdfminimizer_type *T;
gsl_multimin_fdfminimizer *minimizer;
gsl_vector *minimizer_x;
gsl_vector *minimizer_g;
gsl_multimin_function_fdf minimizer_func;
minimizer_pars_struct minimizer_pars;
char *constraints;
char outfile[256];
char constraints_file[256];
char epsilon_file[256];
FILE* fh;
double last_non_nan_lnQ;
pf_overflow = 0;
pf_underflow = 0;
dangles=2;
do_backtrack = 1;
string = NULL;
noPS = 0;
outfile[0]='\0';
epsilon_file[0]='\0';
strcpy(psDir, "dotplots");
if(RNAfold_cmdline_parser (argc, argv, &args_info) != 0) exit(1);
/* RNAbpfold specific options */
if (args_info.tau_given) tau = args_info.tau_arg;
if (args_info.sigma_given) sigma = args_info.sigma_arg;
if (args_info.precision_given) precision = args_info.precision_arg;
if (args_info.step_given) initial_step_size = args_info.step_arg;
if (args_info.maxN_given) max_iteration = args_info.maxN_arg;
if (args_info.minimization_given) method_id = args_info.minimization_arg;
if (args_info.init_given) initial_guess_method = args_info.init_arg;
if (args_info.tolerance_given) tolerance = args_info.tolerance_arg;
if (args_info.outfile_given) strcpy(outfile, args_info.outfile_arg);
if (args_info.constraints_given) strcpy(constraints_file, args_info.constraints_arg);
if (args_info.epsilon_given) strcpy(epsilon_file, args_info.epsilon_arg);
if (args_info.sampleGradient_given) sample_conditionals=1;
if (args_info.hybridGradient_given) {
sample_conditionals=1;
hybrid_conditionals=1;
}
if (args_info.numericalGradient_given) numerical=1;
if (args_info.sampleStructure_given) sample_structure=1;
if (args_info.psDir_given) strcpy(psDir, args_info.psDir_arg);
if (args_info.sparsePS_given) sparsePS=args_info.sparsePS_arg;
if (args_info.gridSearch_given) grid_search = 1;
/* Generic RNAfold options */
if (args_info.temp_given) temperature = args_info.temp_arg;
if (args_info.reference_given) fold_constrained=1;
if (args_info.noTetra_given) tetra_loop=0;
if (args_info.dangles_given) dangles = args_info.dangles_arg;
if (args_info.noLP_given) noLonelyPairs = 1;
if (args_info.noGU_given) noGU = 1;
if (args_info.noClosingGU_given) no_closingGU = 1;
if (args_info.noconv_given) noconv = 1;
if (args_info.energyModel_given) energy_set = args_info.energyModel_arg;
if (args_info.paramFile_given) ParamFile = strdup(args_info.paramFile_arg);
if (args_info.nsp_given) ns_bases = strdup(args_info.nsp_arg);
if (args_info.pfScale_given) sfact = args_info.pfScale_arg;
if (args_info.noPS_given) noPS=1;
/* Create postscript directory */
if (!noPS) {
struct stat stat_p;
if (stat (psDir, &stat_p) != 0) {
if (mkdir(psDir, S_IRWXU|S_IROTH|S_IRGRP ) !=0) {
fprintf(stderr, "WARNING: Could not create directory: %s", psDir);
}
}
}
if (ParamFile != NULL) {
read_parameter_file(ParamFile);
}
if (ns_bases != NULL) {
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-') {
sym=1;
c++;
}
while (*c!='\0') {
if (*c!=',') {
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1))) {
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
/*Read sequence*/
fname[0] = '\0';
while((input_type = get_input_line(&input_string, 0)) & VRNA_INPUT_FASTA_HEADER) {
(void) sscanf(input_string, "%42s", fname);
free(input_string);
}
length = (int) strlen(input_string);
string = strdup(input_string);
free(input_string);
structure = (char *) space((unsigned) length+1);
/* For testing purpose pass dot bracket structure of reference structure via -C */
if (fold_constrained) {
input_type = get_input_line(&input_string, VRNA_INPUT_NOSKIP_COMMENTS);
if(input_type & VRNA_INPUT_QUIT) {
exit(1);
}
else if((input_type & VRNA_INPUT_MISC) && (strlen(input_string) > 0)) {
cstruc = strdup(input_string);
free(input_string);
}
else warn_user("-C was given but reference structure is missing");
}
if(noconv) {
str_RNA2RNA(string);
} else {
str_DNA2RNA(string);
}
/* Allocating space */
epsilon = (double *) space(sizeof(double)*(length+1));
exp_pert = (double **)space(sizeof(double *)*(length+1));
perturbations = (double **)space(sizeof(double *)*(length+1));
prev_epsilon = (double *) space(sizeof(double)*(length+1));
gradient = (double *) space(sizeof(double)*(length+1));
gradient_numeric = (double *) space(sizeof(double)*(length+1));
gradient_numeric_gsl = (double *) space(sizeof(double)*(length+1));
prev_gradient = (double *) space(sizeof(double)*(length+1));
q_unpaired = (double *) space(sizeof(double)*(length+1));
p_unpaired_cond = (double **)space(sizeof(double *)*(length+1));
p_unpaired_cond_sampled = (double **)space(sizeof(double *)*(length+1));
p_pp = (double **)space(sizeof(double *)*(length+1));
p_unpaired = (double *) space(sizeof(double)*(length+1));
p_unpaired_tmp = (double *) space(sizeof(double)*(length+1));
for (i=0; i <= length; i++) {
epsilon[i] = gradient[i] = q_unpaired[i] = 0.0;
p_unpaired_cond[i] = (double *) space(sizeof(double)*(length+1));
p_unpaired_cond_sampled[i] = (double *) space(sizeof(double)*(length+1));
p_pp[i] = (double *) space(sizeof(double)*(length+1));
exp_pert[i] = (double *) space(sizeof(double)*(length+1));
perturbations[i] = (double *) space(sizeof(double)*(length+1));
for (j=0; j <= length; j++) {
p_pp[i][j]=p_unpaired_cond[i][j] = 0.0;
p_unpaired_cond_sampled[i][j] = 0.0;
}
}
/*** If file with perturbation vector epsilon is given we fold using
this epsilon and are done ***/
if (args_info.epsilon_given) {
plist *pl, *pl1,*pl2;
filehandle = fopen (epsilon_file,"r");
if (filehandle == NULL) {
nrerror("Could not open file with perturbation vector.");
}
i=1;
while (1) {
double t;
line = get_line(filehandle);
if (line == NULL) break;
if (i>length) nrerror("Too many values in perturbation vector file.");
if (sscanf(line, "%lf", &epsilon[i]) !=1) {
nrerror("Error while reading perturbation vector file.");
}
i++;
}
if (i-1 != length) {
nrerror("Too few values in perturbation vector file.");
}
init_pf_fold(length);
pf_fold_pb(string, NULL);
sprintf(fname,"%s/dot.ps", psDir);
pl1 = make_plist(length, 1e-5);
(void) PS_dot_plot_list_epsilon(string, fname, NULL, pl1, epsilon, "");
exit(0);
}
/*** Get constraints from reference structure or from external file ***/
/* Structure was given by -C */
if (fold_constrained) {
for (i=0; i<length; i++) {
if (cstruc[i] == '(' || cstruc[i] == ')') {
q_unpaired[i+1] = 0.0;
} else {
q_unpaired[i+1] = 1.0;
}
}
/*Read constraints from file*/
} else {
filehandle = fopen (constraints_file,"r");
if (filehandle == NULL) {
nrerror("No constraints given as dot bracket or wrong file name");
}
i=1;
while (1) {
double t;
line = get_line(filehandle);
if (line == NULL) break;
if (i>length) nrerror("Too many values in constraints.dat");
if (sscanf(line, "%lf", &q_unpaired[i]) !=1) {
nrerror("Error while reading constraints.dat");
}
i++;
}
if (i-1 != length) {
nrerror("Too few values in constraints.dat");
}
}
/* Create file handle */
if (outfile[0] !='\0') {
statsfile = fopen (outfile,"w");
} else {
statsfile = fopen ("stats.dat","w");
}
setvbuf(statsfile, NULL, _IONBF, 0);
if (!grid_search) {
fprintf(statsfile, "Iteration\tDiscrepancy\tNorm\tdfCount\tMEA\tSampled_structure\tSampled_energy\tSampled_distance\tEpsilon\ttimestamp\n");
} else {
/* If we do a grid search we have a different output. */
fprintf(statsfile, "Dummy\tm\tb\tdummy\tMEA\tepsilon\n");
}
if (statsfile == NULL) {
nrerror("Could not open stats.dat for writing.");
}
fprintf(stderr, "tau^2 = %.4f; sigma^2 = %.4f; precision = %.4f; tolerance = %.4f; step-size: %.4f\n\n",
tau, sigma, precision, tolerance, initial_step_size);
st_back=1;
min_en = fold(string, structure);
(void) fflush(stdout);
if (length>2000) free_arrays();
pf_struc = (char *) space((unsigned) length+1);
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(sfact*min_en)/kT/length);
/* Set up minimizer */
minimizer_x = gsl_vector_alloc (length+1);
minimizer_g = gsl_vector_alloc (length+1);
for (i=0; i <= length; i++) {
epsilon[i] = 0.0;
gsl_vector_set (minimizer_g, i, 0.0);
gsl_vector_set (minimizer_x, i, epsilon[i]);
}
minimizer_pars.length=length;
minimizer_pars.seq = string;
minimizer_pars.tau=tau;
minimizer_pars.sigma=sigma;
minimizer_pars.kT=kT;
minimizer_func.n = length+1;
minimizer_func.f = calculate_f;
minimizer_func.df = numerical ? calculate_df_numerically: calculate_df;
minimizer_func.fdf = calculate_fdf;
minimizer_func.params = &minimizer_pars;
//min_en = fold_pb(string, structure);
//fprintf(stderr, "%f", min_en);
//exit(0);
/* Calling test functions for debugging */
for (i=1; i <= length; i++) {
if (i%2==0) {
epsilon[i] = +0.2*i;
} else {
epsilon[i] = -0.2*i;
}
}
//test_folding(string, length);
/* //test_stochastic_backtracking(string, length); */
/* //test_gradient(minimizer_func, minimizer_pars); */
/* //test_gradient_sampling(minimizer_func, minimizer_pars); */
//exit(1);
count_df_evaluations=0;
/* Initial guess for epsilon */
if (initial_guess_method !=0 && initial_guess_method !=3) {
/* Vars for inital guess methods */
double m,b;
double* curr_epsilon;
double* best_epsilon;
double best_m, best_b, best_scale;
double curr_D;
double min_D = 999999999.0;
double inc = +0.25;
double cut;
if (initial_guess_method == 1) fprintf(stderr, "Mathew's constant perturbations\n");
if (initial_guess_method == 2) fprintf(stderr, "Perturbations proportional to q-p\n");
curr_epsilon = (double *) space(sizeof(double)*(length+1));
best_epsilon = (double *) space(sizeof(double)*(length+1));
last_non_nan_lnQ = min_en;
// Calculate p_unpaired for unperturbed state which we need later
// for the proportinal method
if (initial_guess_method == 2) {
init_pf_fold(length);
for (i=0; i <= length; i++) {
epsilon[i] = 0.0;
}
pf_fold_pb(string, NULL);
for (i = 1; i < length; i++) {
for (j = i+1; j<= length; j++) {
p_pp[i][j]=p_pp[j][i]=pr[iindx[i]-j];
}
}
get_pair_prob_vector(p_pp, p_unpaired_tmp, length, 1);
free_pf_arrays();
}
/* We do the same grid search as in the Mathews paper Fig. 4*/
for (m=0.25; m <=7.0; m+=0.25) {
// Weird way of writing this inner loop for the grid search. We
// traverse the grid without big jumps in the parameters to make
// sure that the updated scaling factor is accurate all the time.
inc*=-1;
for (b = inc < 0.0 ? 0.0 : -3.0; inc < 0.0 ? b >= -3.0 : b<= 0.0 ; b+=inc) {
// calculate cut point with x-axis and skip parameter pairs
// which give a cut point outside the range of
// q_unpaired (0 to 1). They gave frequently overflows and the
// idea is that we both want positive and negative perturbations
cut = exp( (-1) * b / m ) - 1;
fprintf(stderr, "\nm = %.2f, b = %.2f, cut=%.2f\n", m, b, cut);
if (cut > 1.0 || cut < 0.01) {
fprintf(stderr, "\nSkipping m = %.2f, b = %.2f\n", m, b);
continue;
}
/* Mathew's constant perturbations */
if (initial_guess_method == 1) {
for (i=0; i <= length; i++) {
/* We add epsilon to unpaired regions (as opposed to
paired regions as in the Mathews paper) so we multiply
by -1; if missing data we set it to 0.0 */
if (q_unpaired[i] < -0.5) {
curr_epsilon[i] = 0.0;
} else {
curr_epsilon[i] = (m *(log(q_unpaired[i]+1))+b) *(-1);
}
gsl_vector_set (minimizer_x, i, curr_epsilon[i]);
}
/* Perturbations proportional to q-p */
} else {
for (i=0; i <= length; i++) {
curr_epsilon[i] = (m *(log(q_unpaired[i]+1)-log(p_unpaired_tmp[i]+1))+ b ) * (-1);
gsl_vector_set (minimizer_x, i, curr_epsilon[i]);
}
}
// Repeat and adjust scaling factor until we get result without over-/underflows
do {
// First we use default scaling factor
if (pf_underflow == 0 && pf_overflow == 0) {
sfact = 1.070;
}
if (pf_underflow) {
sfact *= 0.8;
fprintf(stderr,"Underflow, adjusting sfact to %.4f\n", sfact );
}
if (pf_overflow) {
sfact *= 1.2;
fprintf(stderr,"Overflow, adjusting sfact to %.4f\n", sfact );
}
pf_scale = exp(-(sfact*last_non_nan_lnQ)/kT/length);
//fprintf(stderr,"Scaling factor is now: %.4e\n", pf_scale);
curr_D = calculate_f(minimizer_x, (void*)&minimizer_pars);
if (!isnan(last_lnQ)) last_non_nan_lnQ = last_lnQ;
// Give up when even extreme scaling does not give results
// (for some reason I could not get rid of overflows even with high scaling factors)
if (sfact < 0.1 || sfact > 2.0) break;
} while (pf_underflow == 1 || pf_overflow == 1);
// We have not given up so everything is ok now
if (!(sfact < 0.1 || sfact > 2.0)) {
if (curr_D < min_D) {
min_D = curr_D;
for (i=0; i <= length; i++) {
best_epsilon[i] = curr_epsilon[i];
}
best_m = m;
best_b = b;
best_scale = pf_scale;
}
/*If we are interested in the grid search we misuse the
print_stats function and report m and b together with MEA*/
if (grid_search) {
for (i=0; i <= length; i++) {
epsilon[i] = curr_epsilon[i];
}
print_stats(statsfile, string, cstruc, length, 0, 0, m, 0.0, b, 0);
}
fprintf(stderr, "curr D: %.2f, minimum D: %.2f\n", curr_D, min_D);
// Adjust pf_scale with default scaling factor but lnQ from
// previous step
sfact = 1.070;
pf_scale = exp(-(sfact*last_lnQ)/kT/length);
} else {
sfact = 1.070;
fprintf(stderr, "Skipping m = %.2f, b = %.2f; did not get stable result.\n", m, b);
}
} // for b
} // for m
fprintf(stderr, "Minimum found: m=%.2f, b=%.2f: %.2f\n", best_m, best_b, min_D);
for (i=0; i <= length; i++) {
epsilon[i] = best_epsilon[i];
gsl_vector_set (minimizer_x, i, best_epsilon[i]);
}
pf_scale = best_scale;
}
if (initial_guess_method == 3) {
srand((unsigned)time(0));
for (i=0; i <= length; i++) {
double r = (double)rand()/(double)RAND_MAX * 4 - 2;
epsilon[i] = r;
gsl_vector_set (minimizer_x, i, epsilon[i]);
}
}
/* If we just wanted a grid search we are done now. */
if (grid_search) {
exit(0);
}
prev_D = calculate_f(minimizer_x, (void*)&minimizer_pars);
print_stats(statsfile, string, cstruc, length, 0 , count_df_evaluations , prev_D, -1.0, 0.0,1);
/* GSL minimization */
if (method_id !=0) {
if (method_id > 2) {
char name[100];
// Available algorithms
// 3 gsl_multimin_fdfminimizer_conjugate_fr
// 4 gsl_multimin_fdfminimizer_conjugate_pr
// 5 gsl_multimin_fdfminimizer_vector_bfgs
// 6 gsl_multimin_fdfminimizer_vector_bfgs2
// 7 gsl_multimin_fdfminimizer_steepest_descent
// http://www.gnu.org/software/gsl/manual/html_node/Multimin-Algorithms-with-Derivatives.html
switch (method_id) {
case 2:
minimizer = gsl_multimin_fdfminimizer_alloc (gsl_multimin_fdfminimizer_conjugate_fr, length+1);
strcpy(name, "Fletcher-Reeves conjugate gradient");
break;
case 3:
minimizer = gsl_multimin_fdfminimizer_alloc (gsl_multimin_fdfminimizer_conjugate_pr, length+1);
strcpy(name, "Polak-Ribiere conjugate gradient");
break;
case 4:
minimizer = gsl_multimin_fdfminimizer_alloc ( gsl_multimin_fdfminimizer_vector_bfgs, length+1);
strcpy(name, "Broyden-Fletcher-Goldfarb-Shanno");
break;
case 5:
minimizer = gsl_multimin_fdfminimizer_alloc ( gsl_multimin_fdfminimizer_vector_bfgs2, length+1);
strcpy(name, "Broyden-Fletcher-Goldfarb-Shanno (improved version)");
break;
case 6:
minimizer = gsl_multimin_fdfminimizer_alloc (gsl_multimin_fdfminimizer_steepest_descent, length+1);
strcpy(name, "Gradient descent (GSL implmementation)");
break;
}
fprintf(stderr, "Starting minimization via GSL implementation of %s...\n\n", name);
// The last two parmeters are step size and tolerance (with
// different meaning for different algorithms
gsl_multimin_fdfminimizer_set (minimizer, &minimizer_func, minimizer_x, initial_step_size, tolerance);
iteration = 1;
do {
status = gsl_multimin_fdfminimizer_iterate (minimizer);
D = minimizer->f;
norm = gsl_blas_dnrm2(minimizer->gradient);
print_stats(statsfile, string, cstruc, length,iteration, count_df_evaluations, D, prev_D, norm, iteration%sparsePS == 0);
prev_D = D;
if (status) {
fprintf(stderr, "An unexpected error has occured in the iteration (status:%i)\n", status);
break;
}
status = gsl_multimin_test_gradient (minimizer->gradient, precision);
if (status == GSL_SUCCESS) fprintf(stderr, "Minimum found stopping.\n");
iteration++;
} while (status == GSL_CONTINUE && iteration < max_iteration);
gsl_multimin_fdfminimizer_free (minimizer);
gsl_vector_free (minimizer_x);
/* Custom implementation of steepest descent */
} else {
if (method_id == 1) {
fprintf(stderr, "Starting custom implemented steepest descent search...\n\n");
} else {
fprintf(stderr, "Starting custom implemented steepest descent search with Barzilai Borwein step size...\n\n");
}
iteration = 0;
D = 0.0;
while (iteration++ < max_iteration) {
for (i=1; i <= length; i++) {
gsl_vector_set (minimizer_x, i, epsilon[i]);
}
D = calculate_f(minimizer_x, (void*)&minimizer_pars);
if (numerical) {
calculate_df_numerically(minimizer_x, (void*)&minimizer_pars, minimizer_g);
} else {
calculate_df(minimizer_x, (void*)&minimizer_pars, minimizer_g);
}
for (i=1; i <= length; i++) {
gradient[i] = gsl_vector_get (minimizer_g, i);
}
// Do line search
fprintf(stderr, "\nLine search:\n");
// After the first iteration, use Barzilai-Borwain (1988) step size (currently turned off)
if (iteration>1 && method_id==2) {
double denominator=0.0;
double numerator=0.0;
for (i=1; i <= length; i++) {
numerator += (epsilon[i]-prev_epsilon[i]) * (gradient[i]-prev_gradient[i]);
denominator+=(gradient[i]-prev_gradient[i]) * (gradient[i]-prev_gradient[i]);
}
step_size = numerator / denominator;
norm =1.0;
} else {
// Use step sized given by the user (normalize it first)
step_size = initial_step_size / calculate_norm(gradient, length);
}
for (i=1; i <= length; i++) {
prev_epsilon[i] = epsilon[i];
prev_gradient[i] = gradient[i];
}
do {
for (mu=1; mu <= length; mu++) {
epsilon[mu] = prev_epsilon[mu] - step_size * gradient[mu];
}
for (i=1; i <= length; i++) {
gsl_vector_set (minimizer_x, i, epsilon[i]);
}
DD = calculate_f(minimizer_x, (void*)&minimizer_pars);
if (step_size > 0.0001) {
fprintf(stderr, "Old D: %.4f; New D: %.4f; Step size: %.4f\n", D, DD, step_size);
} else {
fprintf(stderr, "Old D: %.4f; New D: %.4f; Step size: %.4e\n", D, DD, step_size);
}
step_size /= 2;
} while (step_size > 1e-12 && DD > D);
norm = calculate_norm(gradient,length);
if (DD > D) {
fprintf(stderr, "Line search did not improve D in iteration %i. Stop.\n", iteration);
if (hybrid_conditionals) {
sample_conditionals=0;
} else {
break;
}
}
print_stats(statsfile, string, cstruc, length,iteration, count_df_evaluations, DD, prev_D, norm, iteration%sparsePS == 0);
if (norm<precision && iteration>1) {
fprintf(stderr, "Minimum found stopping.\n");
break;
}
prev_D = DD;
}
}
/* Force last dotplot to be printed */
print_stats(statsfile, string, cstruc, length,iteration, count_df_evaluations, DD, prev_D, norm, 1);
}
free(pf_struc);
if (cstruc!=NULL) free(cstruc);
(void) fflush(stdout);
free(string);
free(structure);
RNAfold_cmdline_parser_free (&args_info);
return 0;
}
void main (int argc, char * argv[]) {
Note * nl;
int i;
char *x;
Chord * clist, * m_clist, * cm_clist;
char * parameter_file;
x = strrchr(argv[0], '/');
if (x != NULL) x++; else x = argv[0];
safe_strcpy(this_program, x, sizeof(this_program));
if (argc >= 2 && strcmp(argv[1], "-p") == 0) {
if (argc < 3) usage();
parameter_file = argv[2];
i = 3;
} else {
parameter_file = "parameters";
i = 1;
}
if (argc == i+1) {
/* open the specified notes file */
instream = fopen(argv[i], "r");
if (instream == NULL) {
fprintf(stderr, "%s: Cannot open %s\n", this_program, argv[i]);
my_exit(1);
}
} else if (argc == i) {
instream = stdin;
} else {
usage();
}
read_parameter_file(parameter_file, parameter_file == argv[2]);
alpha = (log(2.0)/(half_life * 1000));
initialize_hashing();
nl = build_note_list_from_input();
label_notes_with_ornamental_dissonance_penalties(nl);
label_notes_with_voice_leading_neighbor(nl);
clist = build_chord_representation(nl);
if (verbosity >= 4) print_chord_list(clist);
m_clist = build_metered_chord_representation(clist);
modify_ornamental_dissonance_penalties(m_clist);
if (verbosity >= 4) print_chord_list(m_clist);
cm_clist = compact_metered_chord_representation(m_clist);
if (verbosity >= 3) print_chord_list(cm_clist);
initialize_harmonic(cm_clist);
compute_harmonic_table();
compute_direct_notes_TPCs(print_chords);
if (verbosity >= 2) print_harmonic();
if (prechord_mode==1) {
print_prechords();
}
if (print_tpc_notes) print_direct_notes();
if (verbosity >= 1) ASCII_display(m_clist);
cleanup_harmonic();
free_chords(clist);
free_chords(m_clist);
free_chords(cm_clist);
/* Did I forget to free the note list and note array? */
}
int main(int argc, char *argv[]) {
int *exitcode;
char **snaplist;
char *fmtstr1, *fmtstr2, ftemp[MAXLEN_FILENAME], **fsnap;
int nsect,errorFlag,i,nsnap,isnap,maxsnap;
int nerror,nskipped,nullcode=-999;
glob_t globbuf;
int ThisTask = 0;
int FileExtension,FormatFlag=0;
/* Pars arguments */
if(argc == 2) {
strcpy(ParameterFile, argv[1]);
FileExtension = -1;
} else if (argc == 3) {
strcpy(ParameterFile, argv[1]);
FileExtension = atoi(argv[2]);
} else {
printf("Parameter file is missing missing.\n");
printf("Call with <ParameterFile> [<FileExtension>]\n");
endrun(1, ThisTask);
}
/* Some initialization stuff */
if (ThisTask == 0) {
/* Read parameter file */
errorFlag = read_parameter_file(ParameterFile);
if (errorFlag) endrun(errorFlag, ThisTask);
nsect = All.NumDivide*All.NumDivide*All.NumDivide;
/* Get file template */
printf("-----------------------------------------\n");
printf("Creating format string from %s...\n",All.PositionFile);
fmtstr1 = strchr(All.PositionFile,'%');
if (fmtstr1) {
fmtstr2 = strchr(fmtstr1,'d');
if (!fmtstr2) {
printf("Format string must be integer (fmtstr = %s)\n",fmtstr1);
endrun(1, ThisTask);
}
FormatFlag = 1;
if (FileExtension >= 0) {
sprintf(ftemp,All.PositionFile,FileExtension);
} else {
strncpy(ftemp,All.PositionFile,fmtstr1-All.PositionFile);
ftemp[fmtstr1-All.PositionFile] = '\0';
strcat(ftemp,"*");
strcat(ftemp,fmtstr2+1);
}
} else {
if (FileExtension >= 0) {
printf("FileExtension provided, but PositionFile in parameters does not contain a format.\n");
endrun(1, ThisTask);
}
strcpy(ftemp,All.PositionFile);
}
/* Search for files */
printf("Searching for files matching %s...\n",ftemp);
errorFlag = glob(ftemp,GLOB_ERR|GLOB_TILDE,NULL,&globbuf);
if (errorFlag) {
printf("glob exited with error code %d\n",errorFlag);
endrun(errorFlag, ThisTask);
}
if ((int)globbuf.gl_pathc == 0) {
printf("No files found.\n");
endrun(1, ThisTask);
} else if (((int)globbuf.gl_pathc > 1) || (FileExtension >= 0)) {
fmtstr1 = strchr(All.FileSuffix,'%');
if (!fmtstr1) {
printf("There are %d files, but the suffix %s does not contain a format.\n",
(int)globbuf.gl_pathc,All.FileSuffix);
globfree( &globbuf );
endrun(1, ThisTask);
}
fmtstr2 = strchr(fmtstr1,'d');
if (!fmtstr2) {
printf("File suffix %s does not contain an integer format specifier.\n",
All.FileSuffix);
globfree( &globbuf );
endrun(1, ThisTask);
}
}
nsnap = (int)globbuf.gl_pathc;
printf("Found %d files matching %s.\n",nsnap,ftemp);
printf("-----------------------------------------\n\n");
fflush(stdout);
/* Copy over files */
exitcode = (int *)malloc(sizeof(int)*nsnap);
snaplist = (char **)malloc(sizeof(char *)*nsnap);
for (fsnap = globbuf.gl_pathv, isnap = 0; *fsnap != NULL; ++fsnap, isnap++ ){
exitcode[isnap] = nullcode;
snaplist[isnap] = strdup(*fsnap);
}
if( nsnap > 0 ) globfree( &globbuf );
/* Get maximum number of snapshots */
if (All.MaxNumSnapshot > 0) {
maxsnap = All.MaxNumSnapshot;
} else {
maxsnap = nsnap;
}
}
/* Loop over files */
nerror = 0;
for (isnap = 0; isnap < maxsnap; isnap++) {
/* Declare private things initialized here */
float **p;
int np,iext,isect,sector[3],ThisTask=0;
char fext[100],blockfile[MAXLEN_FILENAME];
exitcode[isnap] = 0;
/* Get file extension */
if ((nsnap == 1) && (FormatFlag != 1)) {
iext = 0;
strcpy(fext,All.FileSuffix);
} else {
sscanf(snaplist[isnap],All.PositionFile,&iext);
sprintf(fext,All.FileSuffix,iext);
}
printf("Thread %03d: File %d is %s, iext = %d, fext = %s\n",
ThisTask,isnap,snaplist[isnap],iext,fext);
/* Skip reading things if using parts file */
if (All.PositionFileFormat != -1) {
/* Read position file */
np = read_positions_file(snaplist[isnap],&p,ThisTask);
if (np < 0) {
exitcode[isnap] = -np;
np = 0;
}
if (!exitcode[isnap]) {
/* Loop over sectors */
for (isect = 0; isect < nsect ; isect++) {
if (exitcode[isnap]) break;
sector[0] = isect/(All.NumDivide*All.NumDivide);
sector[1] = (isect - (All.NumDivide*All.NumDivide)*sector[0])/All.NumDivide;
sector[2] = isect % All.NumDivide;
namefile_blk(blockfile,fext,sector[0],sector[1],sector[2]);
exitcode[isnap] = voz1b1(sector,blockfile,p,np,ThisTask);
}
}
/* Free positions (change this if voztie will use positions directly) */
if (p != NULL) {
for (i = 0; i < np ; i++)
if (p[i] != NULL) free(p[i]);
free(p);
}
}
/* Tie sectors together */
if (!exitcode[isnap]) exitcode[isnap] = voztie(fext,ThisTask);
/* Count errors */
if (exitcode[isnap]) nerror++;
printf("Thread %03d: exitcode = %d\n",ThisTask,exitcode[isnap]);
fflush(stdout);
}
/* Free file list */
nskipped = 0;
if (nerror > 0)
printf("\nThe following %d snapshot(s) generated an error:\n",nerror);
for ( isnap = 0; isnap < nsnap; isnap++) {
if (exitcode[isnap] == nullcode)
nskipped++;
else if (exitcode[isnap] != 0)
printf(" (exitcode = %4d) %s\n",exitcode[isnap],snaplist[isnap]);
free(snaplist[isnap]);
}
printf("%d snapshots were not processed.\n",nskipped);
free(exitcode);
free(snaplist);
/* Gracefull exit */
endrun(0, 0);
}
/**@brief Main routine of L-Galaxies*/
int main(int argc, char **argv)
{
int filenr, *FileToProcess, *TaskToProcess, nfiles;
char buf[1000];
time_t start, current;
#ifdef PARALLEL
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &ThisTask);
MPI_Comm_size(MPI_COMM_WORLD, &NTask);
#else
NTask = 1;
ThisTask = 0;
#endif //PARALLEL
#ifdef MCMC
time(&global_starting_time);
#endif
if(ThisTask==0)
{
printf("\n\n\n");
printf("**************************************************************************\n");
printf("* *\n");
printf("* Copyright (C) <2016> <L-Galaxies> *\n");
printf("* *\n");
printf("* This program is free software: you can redistribute it and/or modify *\n");
printf("* it under the terms of the GNU General Public License as published by *\n");
printf("* the Free Software Foundation, either version 3 of the License, or *\n");
printf("* (at your option) any later version. *\n");
printf("* *\n");
printf("* This program is distributed in the hope that it will be useful, *\n");
printf("* but WITHOUT ANY WARRANTY; without even the implied warranty of *\n");
printf("* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *\n");
printf("* GNU General Public License for more details. *\n");
printf("* *\n");
printf("* You should have received a copy of the GNU General Public License *\n");
printf("* along with this program. If not, see <http://www.gnu.org/licenses/> *\n");
printf("* *\n");
printf("**************************************************************************\n\n\n");
}
if(argc > 3 || argc<2)
{
printf("\n Wrong number of runtime arguments\n\n");
printf("\n usage: ./L-Galaxies <parameterfile>\n\n");
endrun(0);
}
if (ThisTask == 0)
printf("%s\n",COMPILETIMESETTINGS);
/* check compatibility of some Makefile Options*/
check_options();
/*Reads the parameter file, given as an argument at run time. */
read_parameter_file(argv[1]);
#ifdef MR_PLUS_MRII
//Start with MR files and later change to MRII
LastDarkMatterSnapShot=LastDarkMatterSnapShot_MR;
sprintf(FileWithZList, "%s", FileWithZList_MR);
sprintf(FileWithZList_OriginalCosm, "%s", FileWithZList_OriginalCosm_MR);
#endif
mymalloc_init();
sprintf(FinalOutputDir, "%s", OutputDir);
#ifndef MCMC
if(argc == 3)
sprintf(OutputDir, "%s", argv[2]);
#else
FirstChainNumber=0;
if(argc == 3)
FirstChainNumber=atoi(argv[2]);
#endif
//time(&start);
#ifdef COMPUTE_SPECPHOT_PROPERTIES
//for dust_model
mu_seed = -150;
#endif
init();
#ifdef STAR_FORMATION_HISTORY
#ifdef PARALLEL
if(ThisTask == 0)
#endif
write_sfh_bins();
#endif
#ifndef MCMC
nfiles=get_nr_files_to_process(ThisTask);
FileToProcess=mymalloc("FileToProcess", sizeof(int) * nfiles);
TaskToProcess=mymalloc("TaskToProcess", sizeof(int) * nfiles);
assign_files_to_tasks(FileToProcess, TaskToProcess, ThisTask, NTask, nfiles);
int file;
for(file = 0; file < nfiles; file++)
{
if(ThisTask==TaskToProcess[file])
filenr=FileToProcess[file];
else
continue;
#else //MCMC
/* In MCMC mode only one file is loaded into memory
* and the sampling for all the steps is done on it */
sprintf(SimulationDir, "%s/", SimulationDir);
for(filenr = MCMCTreeSampleFile; filenr <= MCMCTreeSampleFile; filenr++)
{
#endif //MCMC
time(&start);
#ifdef PARALLEL
#ifndef MCMC
time_t current;
do
time(¤t);
//while(difftime(current, start) < 5.0 * ThisTask);
while(difftime(current, start) < 1.0 * ThisTask);
#endif
#endif
load_tree_table(filenr);
#ifdef MCMC
Senna(); // run the model in MCMC MODE
#else
SAM(filenr); // run the model in NORMAL MODE
#endif
#ifdef MCMC
break; //break loop on files since the MCMC is done on a single file
#else
time(¤t);
printf("\ndone tree file %d in %ldmin and %lds\n\n", filenr, (current - start)/60, (current - start)%60);
#endif //MCMC
free_tree_table();
//if temporary directory given as argument
if(argc == 3)
{
#ifdef GALAXYTREE
sprintf(buf, "mv %s/%s_galtree_%d %s", OutputDir,FileNameGalaxies, filenr, FinalOutputDir);
#else
sprintf(buf, "mv %s/%s_z*_%d %s", OutputDir,FileNameGalaxies, filenr, FinalOutputDir);
#endif
system(buf);
}
}
#ifndef MCMC
myfree(TaskToProcess);
myfree(FileToProcess);
#endif
#ifdef PARALLEL
MPI_Finalize();
#endif
return 0;
}
/**@brief SAM() loops on trees and calls construct_galaxies.*/
#ifdef MCMC
double SAM(int filenr)
#else
void SAM(int filenr)
#endif
{
int treenr, halonr;
#ifdef MCMC
int ii;
MCMC_GAL = mymalloc("MCMC_Gal", sizeof(struct MCMC_GALAXY) * MCMCAllocFactor);
for(ii=0;ii<NOUT;ii++)
TotMCMCGals[ii] = 0;
#ifdef MR_PLUS_MRII
change_dark_matter_sim("MR");
#else
if(CurrentMCMCStep==1)
read_sample_info();
#ifdef HALOMODEL
else
{
int snap, ii;
for(snap=0;snap<NOUT;snap++)
for(ii=0;ii<NFofsInSample[snap];ii++)
MCMC_FOF[ii].NGalsInFoF[snap]=0;
}
#endif //HALOMODEL
#endif //MR_PLUS_MRII
#endif //MCMC
//to be used when we have tables for the scaling in any cosmology
//read_scaling_parameters();
#ifndef MCMC
#ifdef GALAXYTREE
create_galaxy_tree_file(filenr);
#else
create_galaxy_files(filenr);
#endif
#endif
#ifdef GALAXYTREE
FILE *fdg = fopen("treengal.dat", "w");
#endif
//***************************************************************************************
//***************************************************************************************
//for(treenr = 0; treenr < NTrees_Switch_MR_MRII; treenr++)
for(treenr = 0; treenr < Ntrees; treenr++)
{
//printf("doing tree %d of %d\n", treenr, Ntrees);
#ifdef MR_PLUS_MRII
if(treenr == NTrees_Switch_MR_MRII)
change_dark_matter_sim("MRII");
#endif
load_tree(treenr);
#ifdef MCMC
#ifdef PRELOAD_TREES
if(CurrentMCMCStep==1)
#endif
#endif
scale_cosmology(TreeNHalos[treenr]);
gsl_rng_set(random_generator, filenr * 100000 + treenr);
NumMergers = 0;
NHaloGal = 0;
#ifdef GALAXYTREE
NGalTree = 0;
IndexStored = 0;
#endif
int snapnum;
//LastSnapShotNr is the highest output snapshot
/* we process the snapshots now in temporal order
* (as a means to reduce peak memory usage) */
for(snapnum = 0; snapnum <= LastSnapShotNr; snapnum++)
{
#ifdef MCMC
/* read the appropriate parameter list for current snapnum
* into the parameter variables to be used in construct_galaxies */
read_mcmc_par(snapnum);
#ifdef HALOMODEL
//because we need halo masses even for FOFs
//with no galaxies it needs to be done here
assign_FOF_masses(snapnum, treenr);
#endif
#endif
for(halonr = 0; halonr < TreeNHalos[treenr]; halonr++)
if(HaloAux[halonr].DoneFlag == 0 && Halo[halonr].SnapNum == snapnum)
construct_galaxies(filenr, treenr, halonr);
}
/* output remaining galaxies as needed */
while(NHaloGal)
output_galaxy(treenr, 0);
#ifndef MCMC
#ifdef GALAXYTREE
save_galaxy_tree_finalize(filenr, treenr);
#ifndef PARALLEL
if((treenr/100)*100==treenr) printf("treenr=%d TotGalCount=%d\n", treenr, TotGalCount);
#endif
fflush(stdout);
fprintf(fdg, "%d\n", NGalTree);
#endif
#else//ifdef MCMC
#endif
free_galaxies_and_tree();
}//loop on trees
#ifdef MCMC
double lhood = get_likelihood();
#ifdef MR_PLUS_MRII
free(MCMC_FOF);
#else
if(CurrentMCMCStep==ChainLength)
free(MCMC_FOF);
#endif
myfree(MCMC_GAL);
return lhood;
#else //MCMC
#ifdef GALAXYTREE
close_galaxy_tree_file();
#else
close_galaxy_files();
#endif
return;
#endif
}
int main(int argc, char *argv[]){
struct RNA2Dfold_args_info args_info;
unsigned int input_type;
char *string, *input_string, *orig_sequence;
char *mfe_structure=NULL, *structure1=NULL, *structure2=NULL, *reference_struc1=NULL, *reference_struc2=NULL;
char *ParamFile=NULL;
int i, j, length, l;
double min_en;
double kT, sfact=1.07;
int pf=0,istty;
int noconv=0;
int circ=0;
int maxDistance1 = -1;
int maxDistance2 = -1;
int do_backtrack = 1;
int stBT = 0;
int nstBT = 0;
string=NULL;
dangles = 2;
struct nbhoods *neighborhoods = NULL;
struct nbhoods *neighborhoods_cur = NULL;
string = input_string = orig_sequence = NULL;
/*
#############################################
# check the command line prameters
#############################################
*/
if(RNA2Dfold_cmdline_parser (argc, argv, &args_info) != 0) exit(1);
/* temperature */
if(args_info.temp_given)
temperature = args_info.temp_arg;
/* max distance to 1st reference structure */
if(args_info.maxDist1_given)
maxDistance1 = args_info.maxDist1_arg;
/* max distance to 2nd reference structure */
if(args_info.maxDist2_given)
maxDistance2 = args_info.maxDist2_arg;
/* compute partition function and boltzmann probabilities */
if(args_info.partfunc_given)
pf = 1;
/* do stachastic backtracking */
if(args_info.stochBT_given){
pf = 1;
stBT = 1;
nstBT = args_info.stochBT_arg;
}
if(args_info.noTetra_given)
tetra_loop=0;
/* assume RNA sequence to be circular */
if(args_info.circ_given)
circ=1;
/* dangle options */
if(args_info.dangles_given)
dangles=args_info.dangles_arg;
/* set number of threads for parallel computation */
if(args_info.numThreads_given)
#ifdef _OPENMP
omp_set_num_threads(args_info.numThreads_arg);
#else
nrerror("\'j\' option is available only if compiled with OpenMP support!");
#endif
/* get energy parameter file name */
if(args_info.parameterFile_given)
ParamFile = strdup(args_info.parameterFile_arg);
/* do not allow GU pairs ? */
if(args_info.noGU_given)
noGU = 1;
/* do not allow GU pairs at the end of helices? */
if(args_info.noClosingGU_given)
no_closingGU = 1;
/* pf scaling factor */
if(args_info.pfScale_given)
sfact = args_info.pfScale_arg;
/* do not backtrack structures ? */
if(args_info.noBT_given)
do_backtrack = 0;
for (i = 0; i < args_info.neighborhood_given; i++){
int kappa, lambda;
kappa = lambda = 0;
if(sscanf(args_info.neighborhood_arg[i], "%d:%d", &kappa, &lambda) == 2);
if ((kappa>-2) && (lambda>-2)){
if(neighborhoods_cur != NULL){
neighborhoods_cur->next = (nbhoods *)space(sizeof(nbhoods));
neighborhoods_cur = neighborhoods_cur->next;
}
else{
neighborhoods = (nbhoods *)space(sizeof(nbhoods));
neighborhoods_cur = neighborhoods;
}
neighborhoods_cur->k = kappa;
neighborhoods_cur->l = lambda;
neighborhoods_cur->next = NULL;
}
}
/* free allocated memory of command line data structure */
RNA2Dfold_cmdline_parser_free (&args_info);
/*
#############################################
# begin actual program code
#############################################
*/
if (ParamFile != NULL)
read_parameter_file(ParamFile);
istty = isatty(fileno(stdout))&&isatty(fileno(stdin));
/*
#############################################
# main loop, continue until end of file
#############################################
*/
do {
if (istty)
print_tty_input_seq_str("Input strings\n1st line: sequence (upper or lower case)\n2nd + 3rd line: reference structures (dot bracket notation)\n@ to quit\n");
while((input_type = get_input_line(&input_string, 0)) & VRNA_INPUT_FASTA_HEADER){
printf(">%s\n", input_string); /* print fasta header if available */
free(input_string);
}
/* break on any error, EOF or quit request */
if(input_type & (VRNA_INPUT_QUIT | VRNA_INPUT_ERROR)){ break;}
/* else assume a proper sequence of letters of a certain alphabet (RNA, DNA, etc.) */
else{
length = (int) strlen(input_string);
string = strdup(input_string);
free(input_string);
}
mfe_structure = (char *) space((unsigned) length+1);
structure1 = (char *) space((unsigned) length+1);
structure2 = (char *) space((unsigned) length+1);
input_type = get_input_line(&input_string, VRNA_INPUT_NOSKIP_COMMENTS);
if(input_type & VRNA_INPUT_QUIT){ break;}
else if((input_type & VRNA_INPUT_MISC) && (strlen(input_string) > 0)){
reference_struc1 = strdup(input_string);
free(input_string);
if(strlen(reference_struc1) != length)
nrerror("sequence and 1st reference structure have unequal length");
}
else nrerror("1st reference structure missing\n");
strncpy(structure1, reference_struc1, length);
input_type = get_input_line(&input_string, VRNA_INPUT_NOSKIP_COMMENTS);
if(input_type & VRNA_INPUT_QUIT){ break;}
else if((input_type & VRNA_INPUT_MISC) && (strlen(input_string) > 0)){
reference_struc2 = strdup(input_string);
free(input_string);
if(strlen(reference_struc2) != length)
nrerror("sequence and 2nd reference structure have unequal length");
}
else nrerror("2nd reference structure missing\n");
strncpy(structure2, reference_struc2, length);
/* convert DNA alphabet to RNA if not explicitely switched off */
if(!noconv) str_DNA2RNA(string);
/* store case-unmodified sequence */
orig_sequence = strdup(string);
/* convert sequence to uppercase letters only */
str_uppercase(string);
if (istty) printf("length = %d\n", length);
min_en = (circ) ? circfold(string, mfe_structure) : fold(string, mfe_structure);
printf("%s\n%s", orig_sequence, mfe_structure);
if (istty)
printf("\n minimum free energy = %6.2f kcal/mol\n", min_en);
else
printf(" (%6.2f)\n", min_en);
printf("%s (%6.2f) <ref 1>\n", structure1, (circ) ? energy_of_circ_structure(string, structure1, 0) : energy_of_structure(string,structure1, 0));
printf("%s (%6.2f) <ref 2>\n", structure2, (circ) ? energy_of_circ_structure(string, structure2, 0) : energy_of_structure(string,structure2, 0));
/* get all variables need for the folding process (some memory will be preallocated here too) */
TwoDfold_vars *mfe_vars = get_TwoDfold_variables(string, structure1, structure2, circ);
mfe_vars->do_backtrack = do_backtrack;
TwoDfold_solution *mfe_s = TwoDfoldList(mfe_vars, maxDistance1, maxDistance2);
if(!pf){
#ifdef COUNT_STATES
printf("k\tl\tn\tMFE\tMFE-structure\n");
for(i = 0; mfe_s[i].k != INF; i++){
printf("%d\t%d\t%lu\t%6.2f\t%s\n", mfe_s[i].k, mfe_s[i].l, mfe_vars->N_F5[length][mfe_s[i].k][mfe_s[i].l/2], mfe_s[i].en, mfe_s[i].s);
if(mfe_s[i].s) free(mfe_s[i].s);
}
free(mfe_s);
#else
printf("k\tl\tMFE\tMFE-structure\n");
for(i = 0; mfe_s[i].k != INF; i++){
printf("%d\t%d\t%6.2f\t%s\n", mfe_s[i].k, mfe_s[i].l, mfe_s[i].en, mfe_s[i].s);
if(mfe_s[i].s) free(mfe_s[i].s);
}
free(mfe_s);
#endif
}
if(pf){
int maxD1 = (int) mfe_vars->maxD1;
int maxD2 = (int) mfe_vars->maxD2;
float mmfe = INF;
double Q;
for(i = 0; mfe_s[i].k != INF; i++){
if(mmfe > mfe_s[i].en) mmfe = mfe_s[i].en;
}
kT = (temperature+K0)*GASCONST/1000.0; /* in Kcal */
pf_scale = exp(-(sfact*mmfe)/kT/length);
if (length>2000)
fprintf(stdout, "scaling factor %f\n", pf_scale);
/* get all variables need for the folding process (some memory will be preallocated there too) */
//TwoDpfold_vars *q_vars = get_TwoDpfold_variables_from_MFE(mfe_vars);
/* we dont need the mfe vars and arrays anymore, so we can savely free their occupying memory */
destroy_TwoDfold_variables(mfe_vars);
TwoDpfold_vars *q_vars = get_TwoDpfold_variables(string, structure1, structure2, circ);
TwoDpfold_solution *pf_s = TwoDpfoldList(q_vars, maxD1, maxD2);
Q = 0.;
for(i = 0; pf_s[i].k != INF; i++){
Q += pf_s[i].q;
}
double fee = (-log(Q)-length*log(pf_scale))*kT;
if(!stBT){
printf("free energy of ensemble = %6.2f kcal/mol\n",fee);
printf("k\tl\tP(neighborhood)\tP(MFE in neighborhood)\tP(MFE in ensemble)\tMFE\tE_gibbs\tMFE-structure\n");
for(i=0; pf_s[i].k != INF;i++){
float free_energy = (-log((float)pf_s[i].q)-length*log(pf_scale))*kT;
if((pf_s[i].k != mfe_s[i].k) || (pf_s[i].l != mfe_s[i].l))
nrerror("This should never happen!");
fprintf(stdout,
"%d\t%d\t%2.8f\t%2.8f\t%2.8f\t%6.2f\t%6.2f\t%s\n",
pf_s[i].k,
pf_s[i].l,
(float)(pf_s[i].q)/(float)Q,
exp((free_energy-mfe_s[i].en)/kT),
exp((fee-mfe_s[i].en)/kT),
mfe_s[i].en,
free_energy,
mfe_s[i].s);
}
}
else{
init_rand();
if(neighborhoods != NULL){
nbhoods *tmp, *tmp2;
for(tmp = neighborhoods; tmp != NULL; tmp = tmp->next){
int k,l;
k = tmp->k;
l = tmp->l;
for(i = 0; i < nstBT; i++){
char *s = TwoDpfold_pbacktrack(q_vars, k, l);
printf("%d\t%d\t%s\t%6.2f\n", k, l, s, q_vars->circ ? energy_of_circ_structure(q_vars->sequence, s, 0) : energy_of_structure(q_vars->sequence, s, 0));
}
}
}
else{
for(i=0; pf_s[i].k != INF;i++){
for(l = 0; l < nstBT; l++){
char *s = TwoDpfold_pbacktrack(q_vars, pf_s[i].k, pf_s[i].l);
printf("%d\t%d\t%s\t%6.2f\n", pf_s[i].k, pf_s[i].l, s, q_vars->circ ? energy_of_circ_structure(q_vars->sequence, s, 0) : energy_of_structure(q_vars->sequence, s, 0));
}
}
}
}
free_pf_arrays();
for(i=0; mfe_s[i].k != INF;i++){
if(mfe_s[i].s) free(mfe_s[i].s);
}
free(pf_s);
free(mfe_s);
/* destroy the q_vars */
destroy_TwoDpfold_variables(q_vars);
}
else
destroy_TwoDfold_variables(mfe_vars);
free_arrays();
free(string);
free(orig_sequence);
free(mfe_structure);
free(structure1);
free(structure2);
free(reference_struc1);
free(reference_struc2);
string = orig_sequence = mfe_structure = NULL;
} while (1);
return 0;
}
int main(int argc, char *argv[])
{
char *string, *line;
char *structure=NULL, *cstruc=NULL;
char fname[30], ffname[20];
char *ParamFile=NULL;
char *ns_bases=NULL, *c;
int i, length, l, sym,r;
int istty;
int noconv=0;
int winsize=70;
int pairdist=0;
float cutoff=0.01;
int hit;
double *pup=NULL; /*prob of being unpaired*/
plist *pl;
int
do_backtrack = 1;
string=NULL;
dangles=2;
unpaired=0;
for (i=1; i<argc; i++) {
if (argv[i][0]=='-')
switch ( argv[i][1] )
{
case 'T': if (argv[i][2]!='\0') usage();
if(i==argc-1) usage();
r=sscanf(argv[++i], "%lf", &temperature);
if (!r) usage();
break;
case 'n':
if ( strcmp(argv[i], "-noGU")==0) noGU=1;
if ( strcmp(argv[i], "-noCloseGU")==0) no_closingGU=1;
if ( strcmp(argv[i], "-noLP")==0) noLonelyPairs=1;
if ( strcmp(argv[i], "-nsp") ==0) {
if (i==argc-1) usage();
ns_bases = argv[++i];
}
if ( strcmp(argv[i], "-noconv")==0) noconv=1;
break;
case '4':
tetra_loop=0;
break;
case 'e':
if(i==argc-1) usage();
r=sscanf(argv[++i],"%d", &energy_set);
if (!r) usage();
break;
case 'c':
if(i==argc-1) usage();
r=sscanf(argv[++i],"%f", &cutoff);
if (!r) usage();
break;
/* case 'C':
fold_constrained=1;
break;
case 'S':
if(i==argc-1) usage();
r=sscanf(argv[++i],"%lf", &sfact);
if (!r) usage();
break;
*/
case 'd': dangles=0;
if (argv[i][2]!='\0') {
r=sscanf(argv[i]+2, "%d", &dangles);
if (r!=1) usage();
if (!dangles%2) usage(); /*1,3 not possible*/
}
break;
case 'P':
if (i==argc-1) usage();
ParamFile = argv[++i];
break;
case 'W':
if (i==argc-1) usage();
r=sscanf(argv[++i], "%d", &winsize);
if (r!=1) usage();
break;
case 'u':
if (i==argc-1) usage();
r=sscanf(argv[++i], "%d", &unpaired);
if (r!=1) usage();
if (unpaired<0) usage();
break;
case 'L':
if (i==argc-1) usage();
r=sscanf(argv[++i], "%d", &pairdist);
if (r!=1) usage();
break;
default: usage();
}
}
if (ParamFile != NULL)
read_parameter_file(ParamFile);
if (ns_bases != NULL) {
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-') {
sym=1; c++;
}
while (*c!='\0') {
if (*c!=',') {
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1))) {
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
istty = isatty(fileno(stdout))&&isatty(fileno(stdin));
if (pairdist==0) pairdist=winsize;
if (pairdist>winsize) {
fprintf(stderr, "pairdist (-L %d) should be <= winsize (-W %d);"
"Setting pairdist=winsize\n",pairdist, winsize);
pairdist=winsize;
}
do { /* main loop: continue until end of file */
if (istty) {
printf("\nInput string (upper or lower case); @ to quit\n");
printf("%s\n", scale);
}
fname[0]='\0';
if ((line = get_line(stdin))==NULL) break;
/* skip comment lines and get filenames */
while ((*line=='*')||(*line=='\0')||(*line=='>')) {
if (*line=='>')
(void) sscanf(line, ">%12s", fname);
printf("%s\n", line);
free(line);
if ((line = get_line(stdin))==NULL) break;
}
if ((line ==NULL) || (strcmp(line, "@") == 0)) break;
string = (char *) space(strlen(line)+1);
(void) sscanf(line,"%s",string);
free(line);
length = (int) strlen(string);
if (unpaired) {
pup=(double *)space((length+1)*sizeof(double));
pup[0]=unpaired;
}
structure = (char *) space((unsigned) length+1);
for (l = 0; l < length; l++) {
string[l] = toupper(string[l]);
if (!noconv && string[l] == 'T') string[l] = 'U';
}
if (istty)
printf("length = %d\n", length);
/* initialize_fold(length); */
update_fold_params();
if (length<winsize) {
fprintf(stderr, "WARN: window size %d larger than sequence length %d\n",
winsize, length);
winsize=length;
}
if (length >= 5) {
pf_scale = -1;
pl=pfl_fold(string, winsize, pairdist, cutoff, pup);
if (fname[0]!='\0') {
strcpy(ffname, fname);
strcat(ffname, "_dp.ps");
}
else strcpy(ffname, "plfold_dp.ps");
PS_dot_plot_turn(string, pl, ffname, pairdist);
free(pl);
if (unpaired) {
putout_pup(pup,length,winsize);
free(pup);
}
if (cstruc!=NULL) free(cstruc);
(void) fflush(stdout);
}
free(string);
free(structure);
} while (1);
return 0;
}
/**@file main.c
* @brief Controlling function of L-Galaxies plus Construct Galaxies,
* Join Galaxies of progenitors, Evolve Galaxies and check
* Makefile options.
* */
int main(int argc, char **argv) {
int filenr, tree, halonr,filenrid,i,j;
struct stat filestatus;
FILE *fd, *fa;
char buf[1000];
time_t initial, final, previous;
//int NFOFs=767;
int *FileList, *TreeList;
int MyNtrees, MytotNHalos, *MyTreeNHalos, NFOFs;
float weight;
long long haloid;
int FileNumber=409024;
/*Reads the parameter file, given as an argument at run time.*/
read_parameter_file(argv[1]);
sprintf(buf, "./sample_nh_%d.dat",FileNumber);
if(!(fd = fopen(buf, "r")))
{
printf("can't open file place 1 `%s'\n", buf);
exit(1);
}
fscanf(fd, "%d \n", &MyNtrees);
printf("NTrees=%d\n", MyNtrees);
FileList = malloc(sizeof(int) * MyNtrees);
TreeList = malloc(sizeof(int) * MyNtrees);
for(i=0;i<MyNtrees;i++)
{
fscanf(fd, "%lld %d %d %f\n", &haloid, &TreeList[i], &FileList[i], &weight);
//printf("i=%d list=%d \n",i,FileList[i]);
}
fclose(fd);
MyTreeNHalos = malloc(sizeof(int) * MyNtrees);
MytotNHalos=0;
//MyNtrees=0;
printf("\n\nReading Started... -> output file %d\n\n\n",FileNumber);
//tree number 3 numbers for the redshift + Nsampling
sprintf(buf, "/afs/mpa/data/bmh20/workspace/performance_MCMC_Scaling_backup/MergerTrees/MergerTrees_1/treedata/trees_063.%d",FileNumber);
if(!(fd = fopen(buf, "wb")))
{
printf("can't open file %d\n", __LINE__);
exit(1);
}
sprintf(buf, "/afs/mpa/data/bmh20/workspace/performance_MCMC_Scaling_backup/MergerTrees/MergerTrees_1/treedata/tree_dbids_063.%d", FileNumber);
if(!(fa = fopen(buf, "wb")))
{
printf("can't open file %d\n", __LINE__);
exit(1);
}
//jump header in output file
/*for (filenr = 0; filenr < NFOFs; filenr++)
if(filenr < 0 || ((FileList[filenr]+TreeList[filenr])!= (FileList[filenr-1]+TreeList[filenr-1])))
++MyNtrees;*/
fseek(fd, sizeof(int) * (2 + MyNtrees),0);
for (filenr = 0; filenr < MyNtrees; filenr++)
{
load_tree_table(FileList[filenr]);
load_tree(FileList[filenr], TreeList[filenr]);
MytotNHalos+=TreeNHalos[TreeList[filenr]];
MyTreeNHalos[filenr]=TreeNHalos[TreeList[filenr]];
printf("Treenr=%d (of %d), Tree Number of Halos=%d\n",filenr, MyNtrees, TreeNHalos[TreeList[filenr]]);
if(fwrite(HaloIDs, sizeof(struct halo_ids_data), MyTreeNHalos[filenr], fa) != MyTreeNHalos[filenr])
printf("error in fwrite\n");
if(fwrite(Halo, sizeof(struct halo_data), MyTreeNHalos[filenr], fd) != MyTreeNHalos[filenr])
printf("error in fwrite\n");
free(HaloAux);
free(Halo);
free(HaloIDs);
for(i = NOUT - 1; i >= 0; i--)
free(TreeNgals[i]);
free(TreeFirstHalo);
free(TreeNHalos);
//printf("done file %d\n", filenr);
// }
}
fclose(fa);
//write header
printf("\n\nRewinding...please wait...\n\n");
rewind(fd);
fwrite(&MyNtrees, sizeof(int), 1, fd);
fwrite(&MytotNHalos, sizeof(int), 1, fd);
fwrite(MyTreeNHalos, sizeof(int), MyNtrees, fd);
free(MyTreeNHalos);
free(FileList);
free(TreeList);
fclose(fd);
printf("\n\ndone");
}
int main(int argc, char *argv[])
{
char *string/*, *line*/;
char *structure=NULL, *cstruc=NULL;
/*char fname[13], ffname[20], gfname[20];*/
/*char *ParamFile=NULL;*/
char *ns_bases=NULL, *c;
int i, length, l, sym/*, r*/;
double energy, min_en;
double kT, sfact=1.07;
int pf=0, noPS=0, istty;
int noconv=0;
int circ=0;
AjPSeq seq = NULL;
AjPFile confile = NULL;
AjPFile paramfile = NULL;
AjPFile outf = NULL;
AjPFile essfile = NULL;
AjPFile dotfilea = NULL;
AjPFile dotfileb = NULL;
AjPStr seqstring = NULL;
AjPStr constring = NULL;
AjPStr seqname = NULL;
float eT = 0.;
AjBool eGU;
AjBool ecirc = ajFalse;
AjBool eclose;
AjBool lonely;
AjBool convert;
AjPStr ensbases = NULL;
AjBool etloop;
AjPStr eenergy = NULL;
char ewt = '\0';
float escale = 0.;
AjPStr edangles = NULL;
char edangle = '\0';
ajint len;
embInitPV("vrnafold",argc,argv,"VIENNA",VERSION);
seqstring = ajStrNew();
constring = ajStrNew();
seqname = ajStrNew();
seq = ajAcdGetSeq("sequence");
confile = ajAcdGetInfile("constraintfile");
paramfile = ajAcdGetInfile("paramfile");
eT = ajAcdGetFloat("temperature");
ecirc = ajAcdGetBoolean("circular");
eGU = ajAcdGetBoolean("gu");
eclose = ajAcdGetBoolean("closegu");
lonely = ajAcdGetBoolean("lp");
convert = ajAcdGetBoolean("convert");
ensbases = ajAcdGetString("nsbases");
etloop = ajAcdGetBoolean("tetraloop");
eenergy = ajAcdGetListSingle("energy");
escale = ajAcdGetFloat("scale");
edangles = ajAcdGetListSingle("dangles");
outf = ajAcdGetOutfile("outfile");
essfile = ajAcdGetOutfile("ssoutfile");
/*
dotfilea = ajAcdGetOutfile("adotoutfile");
dotfileb = ajAcdGetOutfile("bdotoutfile");
*/
do_backtrack = 2;
pf = 0;
string = NULL;
istty = 0;
temperature = (double) eT;
circ = !!ecirc;
noGU = (eGU) ? 0 : 1;
no_closingGU = (eclose) ? 0 : 1;
noLonelyPairs = (lonely) ? 0 : 1;
noconv = (convert) ? 0 : 1;
ns_bases = (ajStrGetLen(ensbases)) ? MAJSTRGETPTR(ensbases) : NULL;
tetra_loop = !!etloop;
ewt = *ajStrGetPtr(eenergy);
if(ewt == '0')
energy_set = 0;
else if(ewt == '1')
energy_set = 1;
else if(ewt == '2')
energy_set = 2;
sfact = (double) escale;
edangle = *ajStrGetPtr(edangles);
if(edangle == '0')
dangles = 0;
else if(edangle == '1')
dangles = 1;
else if(edangle == '2')
dangles = 2;
else if(edangle == '3')
dangles = 3;
if(circ && noLonelyPairs)
{
ajWarn("Depending on the origin of the circular sequence\n"
"some structures may be missed when using -noLP\nTry "
"rotating your sequence a few times\n");
}
if(paramfile)
read_parameter_file(paramfile);
if (ns_bases != NULL)
{
nonstandards = space(33);
c=ns_bases;
i=sym=0;
if (*c=='-')
{
sym=1; c++;
}
while (*c!='\0')
{
if (*c!=',')
{
nonstandards[i++]=*c++;
nonstandards[i++]=*c;
if ((sym)&&(*c!=*(c-1)))
{
nonstandards[i++]=*c;
nonstandards[i++]=*(c-1);
}
}
c++;
}
}
if(confile)
vienna_GetConstraints(confile,&constring);
string = NULL;
structure = NULL;
length = ajSeqGetLen(seq);
string = (char *) space(length+1);
strcpy(string,ajSeqGetSeqC(seq));
len = ajStrGetLen(constring);
structure = (char *) space(length+1);
if(len)
{
fold_constrained = 1;
strcpy(structure,ajStrGetPtr(constring));
}
for (l = 0; l < length; l++) {
string[l] = toupper(string[l]);
if (!noconv && string[l] == 'T') string[l] = 'U';
}
/* initialize_fold(length); */
if (circ)
min_en = circfold(string, structure);
else
min_en = fold(string, structure);
ajFmtPrintF(outf,"%s\n%s", string, structure);
if (istty)
printf("\n minimum free energy = %6.2f kcal/mol\n", min_en);
else
ajFmtPrintF(outf," (%6.2f)\n", min_en);
if (!noPS)
{
if (length<2000)
(void) PS_rna_plot(string, structure, essfile);
else
ajWarn("Structure too long, not doing xy_plot\n");
}
if (length>=2000) free_arrays();
if (pf)
{
char *pf_struc;
pf_struc = (char *) space((unsigned) length+1);
if (dangles==1)
{
dangles=2; /* recompute with dangles as in pf_fold() */
min_en = (circ) ? energy_of_circ_struct(string, structure) :
energy_of_struct(string, structure);
dangles=1;
}
kT = (temperature+273.15)*1.98717/1000.; /* in Kcal */
pf_scale = exp(-(sfact*min_en)/kT/length);
if (length>2000)
ajWarn("scaling factor %f\n", pf_scale);
(circ) ? init_pf_circ_fold(length) : init_pf_fold(length);
if (cstruc!=NULL)
strncpy(pf_struc, cstruc, length+1);
energy = (circ) ? pf_circ_fold(string, pf_struc) :
pf_fold(string, pf_struc);
if (do_backtrack)
{
ajFmtPrintF(outf,"%s", pf_struc);
ajFmtPrintF(outf," [%6.2f]\n", energy);
}
if ((istty)||(!do_backtrack))
ajFmtPrintF(outf," free energy of ensemble = %6.2f kcal/mol\n",
energy);
if (do_backtrack)
{
plist *pl1,*pl2;
char *cent;
double dist, cent_en;
cent = centroid(length, &dist);
cent_en = (circ) ? energy_of_circ_struct(string, cent) :
energy_of_struct(string, cent);
ajFmtPrintF(outf,"%s {%6.2f d=%.2f}\n", cent, cent_en, dist);
free(cent);
pl1 = make_plist(length, 1e-5);
pl2 = b2plist(structure);
(void) PS_dot_plot_list(string, dotfilea, pl1, pl2, "");
free(pl2);
if (do_backtrack==2)
{
pl2 = stackProb(1e-5);
PS_dot_plot_list(string, dotfileb, pl1, pl2,
"Probabilities for stacked pairs (i,j)(i+1,j-1)");
free(pl2);
}
free(pl1);
free(pf_struc);
}
ajFmtPrintF(outf," frequency of mfe structure in ensemble %g; ",
exp((energy-min_en)/kT));
if (do_backtrack)
ajFmtPrintF(outf,"ensemble diversity %-6.2f", mean_bp_dist(length));
ajFmtPrintF(outf,"\n");
free_pf_arrays();
}
if (cstruc!=NULL)
free(cstruc);
free(string);
free(structure);
ajStrDel(&seqstring);
ajStrDel(&constring);
ajStrDel(&seqname);
ajStrDel(&ensbases);
ajStrDel(&eenergy);
ajStrDel(&edangles);
ajSeqDel(&seq);
ajFileClose(&confile);
ajFileClose(¶mfile);
ajFileClose(&outf);
ajFileClose(&essfile);
/*
ajFileClose(&dotfilea);
ajFileClose(&dotfileb);
*/
if (length<2000) free_arrays();
embExit();
return 0;
}
