simulation.cpp

   1 #include<cmath>
   2 #include<cstdio>
   3 #include<cstring>
   4 #include<cstdlib>
   5 #include<cassert>
   6 #include<string>
   7 #include<iostream>
   8 #include<fstream>
   9 #include<vector>
  10
  11 #include "utils.h"
  12 #include "my_assert.h"
  13 #include "Read.h"
  14 #include "SingleRead.h"
  15 #include "SingleReadQ.h"
  16 #include "PairedEndRead.h"
  17 #include "PairedEndReadQ.h"
  18
  19 #include "Model.h"
  20 #include "SingleModel.h"
  21 #include "SingleQModel.h"
  22 #include "PairedEndModel.h"
  23 #include "PairedEndQModel.h"
  24
  25 #include "Refs.h"
  26 #include "Transcript.h"
  27 #include "Transcripts.h"
  28
  29 #include "WriteResults.h"
  30
  31 #include "simul.h"
  32
  33 using namespace std;
  34
  35 bool alleleS;
  36 int OFFSITE;
  37
  38 READ_INT_TYPE N;
  39 int model_type, M;
  40
  41 Refs refs;
  42 Transcripts transcripts;
  43
  44 vector<double> eel;
  45 vector<double> theta, counts;
  46
  47 int n_os;
  48 ostream *os[2];
  49 char outReadF[2][STRLEN];
  50
  51 char refName[STRLEN];
  52 char refF[STRLEN], tiF[STRLEN];
  53
  54 simul sampler;
  55
  56 void genOutReadStreams(int type, char *outFN) {
  57         switch(type) {
  58         case 0 :
  59                 n_os = 1;
  60                 sprintf(outReadF[0], "%s.fa", outFN);
  61                 break;
  62         case 1 :
  63                 n_os = 1;
  64                 sprintf(outReadF[0], "%s.fq", outFN);
  65                 break;
  66         case 2 :
  67                 n_os = 2;
  68                 for (int i = 0; i < n_os; i++)
  69                         sprintf(outReadF[i], "%s_%d.fa", outFN, i + 1);
  70                 break;
  71         case 3 :
  72                 n_os = 2;
  73                 for (int i = 0; i < n_os; i++)
  74                         sprintf(outReadF[i], "%s_%d.fq", outFN, i + 1);
  75                 break;
  76         }
  77
  78         for (int i = 0; i < n_os; i++)
  79                 os[i] = new ofstream(outReadF[i]);
  80 }
  81
  82 template<class ReadType, class ModelType>
  83 void simulate(char* modelF, char* resultsF) {
  84         ModelType model(&refs);
  85         ReadType read;
  86         int sid;
  87
  88         model.read(modelF);
  89
  90         //calculate eel
  91         calcExpectedEffectiveLengths<ModelType>(M, refs, model, eel);
  92
  93         //generate theta vector
  94         ifstream fin(resultsF);
  95         string line;
  96         double tpm;
  97         double denom = 0.0;
  98         getline(fin, line); // read the first line, which is just column names
  99         for (int i = 1; i <= M; i++) {
 100           getline(fin, line);
 101           size_t pos = 0;
 102           for (int j = 0; j < OFFSITE; j++) pos = line.find_first_of('\t', pos) + 1;
 103           size_t pos2 = line.find_first_of('\t', pos);
 104           if (pos2 == string::npos) pos2 = line.length();
 105           tpm = atof(line.substr(pos, pos2 - pos).c_str());
 106           theta[i] = tpm * eel[i]; // during simulation, there is no check for effL < 0. The reason is for that case, eel[i] here = 0 and therefore no chance to sample from it
 107           denom += theta[i];
 108         }
 109         assert(denom > EPSILON);
 110         fin.close();
 111         for (int i = 1; i <= M; i++) theta[i] = theta[i] / denom * (1.0 - theta[0]);
 112
 113         READ_INT_TYPE resimulation_count = 0;
 114
 115         //simulating...
 116         model.startSimulation(&sampler, theta);
 117         for (READ_INT_TYPE i = 0; i < N; i++) {
 118                 while (!model.simulate(i, read, sid)) { ++resimulation_count; }
 119                 read.write(n_os, os);
 120                 ++counts[sid];
 121                 if ((i + 1) % 1000000 == 0 && verbose) cout<<"GEN "<< i + 1<< endl;
 122         }
 123         model.finishSimulation();
 124
 125         cout<< "Total number of resimulation is "<< resimulation_count<< endl;
 126 }
 127
 128 void releaseOutReadStreams() {
 129         for (int i = 0; i < n_os; i++) {
 130                 ((ofstream*)os[i])->close();
 131                 delete os[i];
 132         }
 133 }
 134
 135 int main(int argc, char* argv[]) {
 136         bool quiet = false;
 137         FILE *fi = NULL;
 138
 139         if (argc != 7 && argc != 8) {
 140                 printf("Usage: rsem-simulate-reads reference_name estimated_model_file estimated_isoform_results theta0 N output_name [-q]\n\n");
 141                 printf("Parameters:\n\n");
 142                 printf("reference_name: The name of RSEM references, which should be already generated by 'rsem-prepare-reference'\n");
 143                 printf("estimated_model_file: This file describes how the RNA-Seq reads will be sequenced given the expression levels. It determines what kind of reads will be simulated (single-end/paired-end, w/o quality score) and includes parameters for fragment length distribution, read start position distribution, sequencing error models, etc. Normally, this file should be learned from real data using 'rsem-calculate-expression'. The file can be found under the 'sample_name.stat' folder with the name of 'sample_name.model'\n");
 144                 printf("estimated_isoform_results: This file contains expression levels for all isoforms recorded in the reference. It can be learned using 'rsem-calculate-expression' from real data. The corresponding file users want to use is 'sample_name.isoforms.results'. If simulating from user-designed expression profile is desired, start from a learned 'sample_name.isoforms.results' file and only modify the 'TPM' column. The simulator only reads the TPM column. But keeping the file format the same is required. If the RSEM references built are aware of allele-specific transcripts, 'sample_name.alleles.results' should be used instead.\n");
 145                 printf("theta0: This parameter determines the fraction of reads that are coming from background \"noise\" (instead of from a transcript). It can also be estimated using 'rsem-calculate-expression' from real data. Users can find it as the first value of the third line of the file 'sample_name.stat/sample_name.theta'.\n");
 146                 printf("N: The total number of reads to be simulated. If 'rsem-calculate-expression' is executed on a real data set, the total number of reads can be found as the 4th number of the first line of the file 'sample_name.stat/sample_name.cnt'.\n");
 147                 printf("output_name: Prefix for all output files.\n");
 148                 printf("-q: Set it will stop outputting intermediate information.\n\n");
 149                 printf("Outputs:\n\n");
 150                 printf("output_name.sim.isoforms.results, output_name.sim.genes.results: Expression levels estimated by counting where each simulated read comes from.\n\n");
 151                 printf("output_name.fa if single-end without quality score;\noutput_name.fq if single-end with quality score;\noutput_name_1.fa & output_name_2.fa if paired-end without quality score;\noutput_name_1.fq & output_name_2.fq if paired-end with quality score.\n\n");
 152                 printf("Format of the header line: Each simulated read's header line encodes where it comes from. The header line has the format:\n\n");
 153                 printf("\t{>/@}_rid_dir_sid_pos[_insertL]\n\n");
 154                 printf("{>/@}: Either '>' or '@' must appear. '>' appears if FASTA files are generated and '@' appears if FASTQ files are generated\n");
 155                 printf("rid: Simulated read's index, numbered from 0\n");
 156                 printf("dir: The direction of the simulated read. 0 refers to forward strand ('+') and 1 refers to reverse strand ('-')\n");
 157                 printf("sid: Represent which transcript this read is simulated from. It ranges between 0 and M, where M is the total number of transcripts. If sid=0, the read is simulated from the background noise. Otherwise, the read is simulated from a transcript with index sid. Transcript sid's transcript name can be found in the 'transcript_id' column of the 'sample_name.isoforms.results' file (at line sid + 1, line 1 is for column names)\n");
 158                 printf("pos: The start position of the simulated read in strand dir of transcript sid. It is numbered from 0\n");
 159                 printf("insertL: Only appear for paired-end reads. It gives the insert length of the simulated read.\n\n");
 160                 printf("Example:\n\n");
 161                 printf("Suppose we want to simulate 50 millon single-end reads with quality scores and use the parameters learned from [Example](#example). In addition, we set theta0 as 0.2 and output_name as 'simulated_reads'. The command is:\n\n");
 162                 printf("\trsem-simulate-reads /ref/mouse_125 mmliver_single_quals.stat/mmliver_single_quals.model mmliver_single_quals.isoforms.results 0.2 50000000 simulated_reads\n");
 163                 exit(-1);
 164         }
 165
 166         if (argc == 8 && !strcmp(argv[7], "-q")) quiet = true;
 167         verbose = !quiet;
 168
 169         strcpy(refName, argv[1]);
 170         alleleS = isAlleleSpecific(refName);
 171         OFFSITE = (alleleS ? 6: 5);
 172
 173         //load basic files
 174         sprintf(refF, "%s.seq", argv[1]);
 175         refs.loadRefs(refF);
 176         M = refs.getM();
 177         sprintf(tiF, "%s.ti", argv[1]);
 178         transcripts.readFrom(tiF);
 179
 180         //read model type from modelF
 181         fi = fopen(argv[2], "r");
 182         if (fi == NULL) { fprintf(stderr, "Cannot open %s! It may not exist.\n", argv[2]); exit(-1); }
 183         assert(fscanf(fi, "%d", &model_type) == 1);
 184         fclose(fi);
 185
 186         theta.assign(M + 1, 0.0);
 187         theta[0] = atof(argv[4]);
 188         N = atoi(argv[5]);
 189
 190         genOutReadStreams(model_type, argv[6]);
 191
 192         counts.assign(M + 1, 0.0);
 193
 194         switch(model_type) {
 195         case 0: simulate<SingleRead, SingleModel>(argv[2], argv[3]); break;
 196         case 1: simulate<SingleReadQ, SingleQModel>(argv[2], argv[3]); break;
 197         case 2: simulate<PairedEndRead, PairedEndModel>(argv[2], argv[3]); break;
 198         case 3: simulate<PairedEndReadQ, PairedEndQModel>(argv[2], argv[3]); break;
 199         }
 200
 201         writeResultsSimulation(M, refName, argv[6], transcripts, eel, counts);
 202         releaseOutReadStreams();
 203
 204         return 0;
 205 }