Пример #1
0
  public double likelihood() {
    double c1 = 0.0;
    double c3 = -1.0 / (double) Math.sqrt(2.0 * variance);
    double sum = 0.0;

    double cpart = -0.5 * Math.log(Math.sqrt(2.0 * Math.PI * variance));

    for (int i = 0; i < data.size(); i++) {
      for (int k = 0; k < channels.length; k++) {
        c1 += cpart;
        double pi = 0.0;

        for (Integer t : transcripts.keySet()) {
          if (transcripts.get(t).contains(i)) {
            double gammai = gammas[t][k];
            double dit = delta(i, t);

            double pit = gammai * Math.exp(-lambda * dit);
            pi += pit;
          }
        }

        double zi = Math.log(pi);
        double err = data.values(i)[channels[k]] - zi;

        sum += (err * err);
      }
    }

    return c1 + c3 * sum;
  }
Пример #2
0
  public double error() {
    double sum = 0.0;

    for (int i = 0; i < data.size(); i++) {
      for (int k = 0; k < channels.length; k++) {
        double pi = 0.0;

        for (Integer t : transcripts.keySet()) {
          if (transcripts.get(t).contains(i)) {
            double gammai = gammas[t][k];
            double dit = delta(i, t);

            double pit = gammai * Math.exp(-lambda * dit);
            pi += pit;
          }
        }

        double zi = Math.log(pi);
        double err = Math.abs(data.values(i)[channels[k]] - zi);

        sum += err;
      }
    }

    return sum;
  }
Пример #3
0
  public static ClusterData makeCd(
      final int lane,
      final int tile,
      final int xCoord,
      final int yCoord,
      final boolean pf,
      final byte[] bases,
      final byte[] qualities,
      final String matchedBarcode) {
    final ReadData rd = new ReadData();
    rd.setBases(Arrays.copyOf(bases, bases.length));
    rd.setQualities(Arrays.copyOf(qualities, bases.length));
    rd.setReadType(
        ReadType.T); // This will be ignored, as the cluster will be chopped up by ReadStructure

    final ClusterData cd = new ClusterData(rd);
    cd.setLane(lane);
    cd.setTile(tile);
    cd.setX(xCoord);
    cd.setY(yCoord);
    cd.setPf(pf);
    cd.setMatchedBarcode(matchedBarcode);

    return cd;
  }
Пример #4
0
  public ClusterLikelihoods(
      ClusterData d, Integer[] chs, int[] five, int[] three, double v, double l) {
    data = d;
    channels = chs.clone();

    gammas = new double[five.length][channels.length];
    for (int t = 0; t < gammas.length; t++) {
      for (int i = 0; i < gammas[t].length; i++) {
        gammas[t][i] = 1.0;
      }
    }

    transcripts = new TreeMap<Integer, Set<Integer>>();
    fiveprime = five;
    threeprime = three;

    if (fiveprime.length != threeprime.length) {
      String msg = String.format("%d != %d", fiveprime.length, threeprime.length);
      throw new IllegalArgumentException(msg);
    }

    variance = v;
    lambda = l;

    for (int t = 0; t < fiveprime.length; t++) {
      transcripts.put(t, new TreeSet<Integer>());
    }

    for (int i = 0; i < data.size(); i++) {
      int loc = data.location(i);
      for (int t = 0; t < fiveprime.length; t++) {
        if (fiveprime[t] <= loc && threeprime[t] >= loc) {
          transcripts.get(t).add(i);
        }
      }
    }
  }
Пример #5
0
  public static ReadData[] copyReadData(
      final ReadStructure rs, final IlluminaDataType[] dts, final ClusterData toCopy) {
    boolean doBases = false;
    boolean doQuals = false;
    boolean doInts = false;
    boolean doNoise = false;

    for (final IlluminaDataType dt : dts) {
      switch (dt) {
        case BaseCalls:
          doBases = true;
          break;

        case QualityScores:
          doQuals = true;
          break;

        case RawIntensities:
          doInts = true;
          break;

        case Noise:
          doNoise = true;
          break;
      }
    }

    if (!doBases && !doQuals && !doInts && !doNoise) return null;

    final ReadData rdToCopy = toCopy.getRead(0); // Only gonna be one read in this
    final ReadData[] rds = new ReadData[rs.nonSkips.length()];

    int index = 0;
    int baseIndex = 0;
    for (int i = 0; i < rs.descriptors.size(); i++) {
      final ReadDescriptor readDesc = rs.descriptors.get(i);

      if (readDesc.type != ReadType.S) {
        final ReadData curRead = new ReadData(readDesc.type);
        if (doBases) {
          final byte[] bases =
              Arrays.copyOfRange(rdToCopy.getBases(), baseIndex, baseIndex + readDesc.length);
          curRead.setBases(bases);
        }

        if (doQuals) {
          final byte[] quals =
              Arrays.copyOfRange(rdToCopy.getQualities(), baseIndex, baseIndex + readDesc.length);
          curRead.setQualities(quals);
        }

        if (doInts) {
          final FourChannelIntensityData fcid =
              copyIntensities(rdToCopy.getRawIntensities(), baseIndex, readDesc.length);
          curRead.setRawIntensities(fcid);
        }

        if (doNoise) {
          final FourChannelIntensityData fcid =
              copyIntensities(rdToCopy.getNoise(), baseIndex, readDesc.length);
          curRead.setNoise(fcid);
        }
        rds[index++] = curRead;
      }

      baseIndex += readDesc.length;
    }

    return rds;
  }
Пример #6
0
  public static ClusterData selectiveCopyCd(
      final ClusterData toCopy, final String readStructure, final IlluminaDataType... dataTypes) {
    final ReadStructure rs = new ReadStructure(readStructure);
    final ReadData[] rd = copyReadData(rs, dataTypes, toCopy);
    final ClusterData cd = new ClusterData(rd);
    cd.setTile(toCopy.getTile());
    cd.setLane(toCopy.getLane());

    for (final IlluminaDataType idt : dataTypes) {
      switch (idt) {
        case Position:
          cd.setX(toCopy.getX());
          cd.setY(toCopy.getY());
          break;

        case PF:
          cd.setPf(toCopy.isPf());
          break;

        case Barcodes:
          cd.setMatchedBarcode(toCopy.getMatchedBarcode());
          break;

        default:
          break;
      }
    }

    return cd;
  }
Пример #7
0
 public double delta(int i, int t) {
   int diff = threeprime[t] - data.location(i);
   return diff >= 0 ? (double) diff : 0.0;
 }