Changeset 80


Ignore:
Timestamp:
Mar 24, 2006, 12:47:38 PM (15 years ago)
Author:
Johan Enell
Message:

redesign of code
includeAssays parameter added

Location:
trunk/se/lu/onk/ReplicateError
Files:
1 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/se/lu/onk/ReplicateError/lib/pluginConfigurationAA.base

    r55 r80  
    26266 t sort  Sort  10      0
    27277 e leaveSingletons Leave singletons  30  false true\tyes\tfalse\tno  0
    28 
     288 t includeassays Include assays  30    0
  • trunk/se/lu/onk/ReplicateError/src/replicateerror/AcrossAssays/ReplicateErrorAA.java

    r56 r80  
    2727import java.util.Comparator;
    2828import java.util.HashMap;
     29import java.util.HashSet;
    2930import java.util.Iterator;
    3031import java.util.List;
     32import java.util.Set;
    3133import java.util.regex.Matcher;
    3234import java.util.regex.Pattern;
     
    4042import replicateerror.Replicate;
    4143import replicateerror.ReplicateError;
     44import replicateerror.Spot;
    4245
    4346public class ReplicateErrorAA extends ReplicateError
     
    4750  private List<Integer> group;
    4851
    49   private HashMap<String, List<String>> groups;
    50 
    51   private HashMap<String, String> assayName;
    52 
    53   private List<String> noGroup;
     52  private HashMap<String, List<Integer>> groups;
     53
     54  private HashMap<Integer, String> assayName;
     55
     56  private List<Integer> noGroup;
    5457
    5558  private int sort;
    56 
     59 
     60  private Set<String> includeAssays;
     61 
    5762  public ReplicateErrorAA()
    5863  {
    5964    super();
    60     groups = new HashMap<String, List<String>>();
    61     assayName = new HashMap<String, String>();
    62     noGroup = new ArrayList<String>();
     65    includeAssays = new HashSet<String>();
     66    groups = new HashMap<String, List<Integer>>();
     67    assayName = new HashMap<Integer, String>();
     68    noGroup = new ArrayList<Integer>();
    6369    File dataDir = new File("data");
    6470    dataDir.mkdir();
     
    125131      }
    126132    }
     133    if (!section.findStringOpt("includeassays").equals(""))
     134    {
     135      includeAssays.addAll(Arrays.asList(section.findStringOpt("includeassays").trim().split("\\s*\\|\\s*")));
     136    }
    127137  }
    128138
     
    140150      while ((vals = bfr.readDataRow()) != null)
    141151      {
    142         assayName.put(vals[idCol], vals[nameCol]);
    143 
    144         Matcher m = assayPattern.matcher(vals[nameCol]);
    145         if (m.matches())
    146         {
    147           String groupName = m.group(group.get(0));
    148           for (int i = 1; i < group.size(); i++)
    149           {
    150             groupName += "_" + m.group(group.get(i));
    151           }
    152           List<String> assayGroup = groups.get(groupName);
    153           if (assayGroup == null)
    154           {
    155             assayGroup = new ArrayList<String>();
    156           }
    157           assayGroup.add(vals[idCol]);
    158           groups.put(groupName, assayGroup);
     152        assayName.put(new Integer(vals[idCol]), vals[nameCol]);
     153
     154        if (includeAssays.isEmpty() || includeAssays.contains(vals[nameCol]))
     155        {
     156          Matcher m = assayPattern.matcher(vals[nameCol]);
     157          if (m.matches())
     158          {
     159            String groupName = m.group(group.get(0));
     160            for (int i = 1; i < group.size(); i++)
     161            {
     162              groupName += "_" + m.group(group.get(i));
     163            }
     164            List<Integer> assayGroup = groups.get(groupName);
     165            if (assayGroup == null)
     166            {
     167              assayGroup = new ArrayList<Integer>();
     168            }
     169            assayGroup.add(new Integer(vals[idCol]));
     170            groups.put(groupName, assayGroup);
     171          }
     172          else
     173          {
     174            HTML.addGroupNoGroup(vals[nameCol]);
     175            noGroup.add(new Integer(vals[idCol]));
     176            System.err.println(vals[nameCol] + " didn't match " + assayPattern.pattern());
     177          }
    159178        }
    160179        else
    161180        {
    162181          HTML.addGroupNoGroup(vals[nameCol]);
    163           noGroup.add(vals[idCol]);
    164           System.err.println(vals[nameCol] + " didn't match " + assayPattern.pattern());
     182          noGroup.add(new Integer(vals[idCol]));
     183          System.err.println(vals[nameCol] + " was exculded from the filtering due to the \"includeassay\" parameter");
    165184        }
    166185      }
     
    169188      if (sort >= 0)
    170189      {
    171         for (List<String> assayGroup : groups.values())
    172         {
    173           Collections.sort(assayGroup, new Comparator<String>()
    174           {
    175             public int compare(String assay1, String assay2)
     190        for (List<Integer> assayGroup : groups.values())
     191        {
     192          Collections.sort(assayGroup, new Comparator<Integer>()
     193          {
     194            public int compare(Integer assay1, Integer assay2)
    176195            {
    177196              Matcher m1 = assayPattern.matcher(assayName.get(assay1));
     
    190209      {
    191210        String key = it.next();
    192         List<String> group = groups.get(key);
     211        List<Integer> group = groups.get(key);
    193212        if (group.size() == 1)
    194213        {
     
    211230  }
    212231
    213   private List<String> assayIdToName(List<String> assayId)
     232  private List<String> assayIdToName(List<Integer> assayId)
    214233  {
    215234    List<String> result = new ArrayList<String>(assayId.size());
    216     for (String id : assayId)
     235    for (Integer id : assayId)
    217236    {
    218237      result.add(assayName.get(id));
     
    226245    List<String> columns = section.findFieldList("columns");
    227246    List<String> assayFields = section.findFieldList("assayFields");
    228     List<String> assays = section.findFieldList("assays");
     247    List<Integer> assays = section.findFieldIntList("assays");
    229248
    230249    int posCol = columns.indexOf("position");
     
    234253    int int2Col = assayFields.indexOf("intensity2");
    235254
    236     HashMap<String, Integer> assayColumns = new HashMap<String, Integer>();
     255    HashMap<Integer, Integer> assayColumns = new HashMap<Integer, Integer>();
    237256    for (int i = 0; i < assays.size(); i++)
    238257    {
     
    252271      for (String groupName : groups.keySet())
    253272      {
    254         List<String> assayGroup = groups.get(groupName);
    255         spotSection.setHeader("assays", assayGroup.toArray());
    256         System.out.println(spotSection);
    257         HashMap<Integer, ReplicateList> replicates = new HashMap<Integer, ReplicateList>();
     273        List<Integer> assayGroup = groups.get(groupName);
     274        HashMap<Integer, Replicate> replicates = new HashMap<Integer, Replicate>();
     275        HashMap<Integer, Replicate> singletons = new HashMap<Integer, Replicate>();
     276       
    258277        String[] vals;
    259278        while ((vals = bfr.readDataRow()) != null)
    260279        {
    261280          int reporter = new Integer(vals[repCol]);
    262           int position = new Integer(vals[posCol]);
    263           ReplicateList replicate = replicates.get(reporter);
     281          Replicate replicate = replicates.get(reporter);
    264282          if (replicate == null)
    265283          {
    266             replicate = new ReplicateList();
    267           }
    268 
    269           Replicate r = new Replicate(position, reporter);
     284            replicate = new Replicate();
     285          }
     286
    270287          for (int i = 0; i < assayGroup.size(); i++)
    271288          {
    272289            float int1;
    273290            float int2;
     291            int position = -1;
    274292            try
    275293            {
    276               String assay = assayGroup.get(i);
    277               int1 = new Float(vals[assayColumns.get(assay) + int1Col]);
    278               int2 = new Float(vals[assayColumns.get(assay) + int2Col]);
     294              int assayCol = assayColumns.get(assayGroup.get(i));
     295              position = new Integer(vals[posCol]);
     296              int1 = new Float(vals[assayCol + int1Col]);
     297              int2 = new Float(vals[assayCol + int2Col]);
    279298              if (int1 <= 0 || int2 <= 0)
    280299              {
     
    288307              int2 = Float.NaN;
    289308            }
    290             r.addIntensity(int1, int2);
    291           }
     309            if (position >= 0)
     310            {
     311              Spot s = replicate.getAssaySpot(assayGroup.get(i));
     312              if (s == null)
     313              {
     314                s = new Spot(assayGroup.get(i));
     315                replicate.add(s);
     316              }
     317              s.add(position, int1, int2);
     318            }
     319          }
     320          replicates.put(reporter, replicate);
     321        }
     322
     323        Iterator<Integer> i = replicates.keySet().iterator();
     324        while (i.hasNext())
     325        {
     326          Integer reporter = i.next();
     327          Replicate r = replicates.get(reporter);
    292328          if (r.valid())
    293329          {
    294             replicate.add(r);
    295             replicates.put(reporter, replicate);
    296             R.replica1Range(r.getM(0));
    297             R.replica2Range(r.getM(1));
    298             R.replicaMRange(r.getReplicateM(0, 1));
    299           }
    300           else if (leaveSingletons)
    301           {
    302             System.out.println(r.asTabString());
    303           }
    304         }
    305 
    306 
    307         // calculate mean or median
    308         List<Float> mList = getMList(replicates);
     330            Iterator<Spot[]> dupI = r.duplicateIterator();
     331            while (dupI.hasNext())
     332            {
     333              Spot[] d = dupI.next();
     334              R.replica1Range(d[0].getM());
     335              R.replica2Range(d[1].getM());
     336              R.replicaMRange(Replicate.getReplicateM(d[0], d[1]));
     337            }
     338          }
     339          else
     340          {
     341            i.remove();
     342            if (leaveSingletons && r.size() == 1)
     343            {
     344              singletons.put(reporter, r);
     345            }
     346          }
     347        }
     348       
     349        // calculate mean or median befor filter
     350        List<Float> mList = getMList(replicates.values());
    309351        float averageBefore;
    310352        int nbrBefore = mList.size();
     
    317359          averageBefore = mean(mList);
    318360        }
    319         // Calculate standard deviation
     361        // Calculate standard deviation befor filter
    320362        float sdBefore = standardDiviation(mList, mean(mList));
    321363
    322         R.setABRBefore(groupName, caluculateABR(replicates));
     364        R.setABRBefore(groupName, caluculateABR(replicates.values()));
    323365
    324366        // print result
    325         PrintStream allReplicates = new PrintStream(new File("data", groupName + ".data"));
    326         PrintStream goodReplicates = new PrintStream(new File("data", groupName + "good.data"));
    327 
    328         // filter replicates abs(M - mean) against 'sdLimit' number of sd's
    329         Iterator<ReplicateList> it = replicates.values().iterator();
    330         while (it.hasNext())
    331         {
    332           ReplicateList replicateList = it.next();
    333           boolean allBad = true;
    334           int size = replicateList.get(0).getSize();
    335           boolean[] goodSpots = new boolean[size];
    336           Arrays.fill(goodSpots, false);
    337 
    338           for (int i = 0; i < size - 1; i++)
    339           {
    340             for (int j = i + 1; j < size; j++)
    341             {
    342               float m = replicateList.getReplicateM(i, j);
    343               if (!Float.isNaN(m))
    344               {
    345                 allReplicates.println(replicateList.getRatio(i) + "\t" + replicateList.getRatio(j));
    346               }
    347               if (Math.abs(m - averageBefore) < sdLimit * sdBefore)
    348               {
    349                 goodSpots[i] = true;
    350                 goodSpots[j] = true;
    351                 goodReplicates.println(replicateList.getRatio(i) + "\t" + replicateList.getRatio(j));
    352                 allBad = false;
    353               }
    354               else
    355               {
    356                
    357 //                 it.remove();
    358               }
    359             }
    360           }
    361 //          if (!allBad)
    362 //          {
    363             for (Replicate replicate : replicateList)
    364             {
    365               System.out.print(replicate.getPosition()+"\t"+replicate.getReporter());
    366               for (int i = 0; i < goodSpots.length; i++)
    367               {
    368                 if (goodSpots[i])
    369                 {
    370                   System.out.print("\t"+replicate.getInt1(i)+"\t"+replicate.getInt2(i));
    371                 }
    372                 else
    373                 {
    374                   replicate.setInt1(i, Float.NaN);
    375                   replicate.setInt2(i, Float.NaN);
    376                   System.out.print("\t\t");
    377                 }
    378               }
    379               System.out.println();
    380             }
    381 //          }
    382         }
    383         System.out.println();
    384 
    385         // calculate mean
    386         mList = getMList(replicates);
     367        printDuplicates(replicates.values(), groupName + ".data");
     368       
     369        // filter replicates abs(M - mean) against 'sdLimit' number of sd's
     370        for (Replicate r : replicates.values())
     371        {
     372          r.filter(averageBefore, sdLimit * sdBefore);
     373        }
     374        printDuplicates(replicates.values(), groupName + "good.data");
     375       
     376        // calculate mean after filter
     377        mList = getMList(replicates.values());
    387378        float averageAfter;
    388379        if (center == Center.median)
     
    394385          averageAfter = mean(mList);
    395386        }
    396         // Calculate standard deviation
     387        // Calculate standard deviation after filter
    397388        float sdAfter = standardDiviation(mList, mean(mList));
    398389
    399         R.setABRAfter(groupName, caluculateABR(replicates));
    400 
     390        R.setABRAfter(groupName, caluculateABR(replicates.values()));
     391
     392        for (Integer assay : assayGroup)
     393        {
     394          spotSection.setHeader("assays", assay);
     395          System.out.println(spotSection);
     396          printSpots(assay, replicates);
     397          printSpots(assay, singletons);
     398          System.out.println();
     399        }
     400       
    401401        HTML.addPlotsTable(groupName, averageBefore, sdBefore, nbrBefore, averageAfter, sdAfter, mList.size());
    402402        bfr.resetDataPosition(section);
     
    414414          System.out.print(vals[posCol] + "\t" + vals[repCol]);
    415415
    416           for (String assay : noGroup)
     416          for (Integer assay : noGroup)
    417417          {
    418418            System.out.print("\t" + vals[assayColumns.get(assay) + int1Col]);
     
    429429    }
    430430  }
    431 
    432   private float[] caluculateABR(HashMap<Integer, ReplicateList> replicates)
    433   {
    434     float[] result = new float[3]; // a b r
    435 
    436     float meanX = 0;
    437     float meanY = 0;
    438     float ssxx = 0;
    439     float ssyy = 0;
    440     float ssxy = 0;
    441 
    442     for (ReplicateList r : replicates.values())
    443     {
    444       float m1 = r.getM(0);
    445       float m2 = r.getM(1);
    446 
    447       meanX += m1;
    448       meanY += m2;
    449       ssxx += Math.pow(m1, 2);
    450       ssyy += Math.pow(m2, 2);
    451       ssxy += m1 * m2;
    452     }
    453     meanX /= replicates.size();
    454     meanY /= replicates.size();
    455     ssxx = ssxx - replicates.size() * meanX * meanX;
    456     ssyy = ssyy - replicates.size() * meanY * meanY;
    457     ssxy = ssxy - replicates.size() * meanX * meanY;
    458 
    459     result[1] = ssxy / ssxx;
    460     result[0] = meanY - result[1] * meanX;
    461     result[2] = (float) Math.sqrt((ssxy * ssxy) / (ssxx * ssyy));
    462 
    463     return result;
    464   }
    465 
    466   private List<Float> getMList(HashMap<Integer, ReplicateList> replicates)
    467   {
    468     List<Float> l = new ArrayList<Float>();
    469     for (ReplicateList replicateList : replicates.values())
    470     {
    471       int size = replicateList.get(0).getSize();
    472       for (int i = 0; i < size - 1; i++)
    473       {
    474         for (int j = i+1; j < size; j++)
    475         {
    476           float m = replicateList.getReplicateM(i, j);
    477           if(!Float.isNaN(m))
    478           {
    479             l.add(m);
    480           }
    481         }
    482       }
    483     }
    484     return l;
    485   }
    486 
    487431}
  • trunk/se/lu/onk/ReplicateError/src/replicateerror/Replicate.java

    r56 r80  
    2020
    2121import java.util.ArrayList;
     22import java.util.HashSet;
     23import java.util.Iterator;
     24import java.util.NoSuchElementException;
     25import java.util.Set;
    2226
    2327public class Replicate
     28  extends ArrayList<Spot>
    2429{
    25   private int size = 0;
    2630
    27   private int reporter;
    28 
    29   private int position;
    30 
    31   private ArrayList<Float> int2;
    32 
    33   private ArrayList<Float> int1;
    34 
    35   public Replicate(int position, int reporter)
     31  public Spot getAssaySpot(int assay)
    3632  {
    37     this.reporter = reporter;
    38     this.position = position;
    39     this.int1 = new ArrayList<Float>();
    40     this.int2 = new ArrayList<Float>();
     33    for(Spot s : this)
     34    {
     35      if (s.getAssay() == assay)
     36      {
     37        return s;
     38      }
     39    }
     40    return null;
     41  }
     42 
     43  public final float getReplicateRatio(int s1, int s2)
     44  {
     45    return get(s1).getM() / get(s2).getM();
    4146  }
    4247
    43   public void addIntensity(float int1, float int2)
     48  public float getReplicateM(int s1, int s2)
    4449  {
    45     this.int1.add(int1);
    46     this.int2.add(int2);
    47     this.size++;
     50    return (float) (Math.log(getReplicateRatio(s1, s2)) / Math.log(2));
    4851  }
    4952
    50   public float getInt1(int i)
    51   {
    52     return int1.get(i);
    53   }
    54 
    55   public void setInt1(int i, float intensity)
    56   {
    57     this.int1.set(i, intensity);
    58   }
    59 
    60   public float getInt2(int i)
    61   {
    62     return int2.get(i);
    63   }
    64 
    65   public void setInt2(int i, float intensity)
    66   {
    67     this.int2.set(i, intensity);
    68   }
    69 
    70   public final int getPosition()
    71   {
    72     return position;
    73   }
    74 
    75   public final int getReporter()
    76   {
    77     return reporter;
    78   }
    79 
    80   public float getRatio(int i)
    81   {
    82     return int1.get(i) / int2.get(i);
    83   }
    84 
    85   public float getM(int i)
    86   {
    87     return (float) (Math.log(getRatio(i)) / Math.log(2));
    88   }
    89 
    90   public float getReplicateM(int repl1, int repl2)
    91   {
    92     float r1 = getRatio(repl1);
    93     float r2 = getRatio(repl2);
    94 
    95     return (float) (Math.log(r1 / r2) / Math.log(2));
    96   }
    97 
    98   public int getSize()
    99   {
    100     return size;
    101   }
    102 
    103   public boolean valid()
     53  /**
     54   * Returns false if there isnt any replicate with a valid M value.
     55   */
     56  public final boolean valid()
    10457  {
    10558    boolean result = false;
    106     for (int i = 0; i < getSize(); i++)
     59    if (size() < 2) return false;
     60    Iterator<Spot[]> i = duplicateIterator();
     61    while (i.hasNext())
    10762    {
    108       float r1 = getRatio(i);
    109       for (int j = i + 1; j < getSize(); j++)
    110       {
    111         float r2 = getRatio(j);
    112         result |= !Double.isNaN((Math.log(r1 / r2) / Math.log(2)));
    113       }
     63      Spot[] d = i.next();
     64      result |= !Float.isNaN(getReplicateRatio(d[0], d[1]));
    11465    }
    11566    return result;
    11667  }
    11768
    118   public String asTabString()
     69  public void filter(float from, float threshold)
    11970  {
    120     String ret = position + "\t" + reporter;
    121     for (int i = 0; i < getSize(); i++)
     71    Set<Spot> good = new HashSet<Spot>();
     72    Iterator<Spot[]> i = duplicateIterator();
     73    while (i.hasNext())
    12274    {
    123       ret += "\t" + int1.get(i) + "\t" + int2.get(i);
     75      Spot[] d = i.next();
     76      if (Math.abs(getReplicateM(d[0], d[1]) - from) < threshold)
     77      {
     78        good.add(d[0]);
     79        good.add(d[1]);
     80      }
    12481    }
    125     return ret;
     82    this.retainAll(good);
    12683  }
     84 
     85  public final Iterator<Spot[]> duplicateIterator()
     86  {
     87    return new Iterator<Spot[]>()
     88    {
     89      private int i = 0;
     90      private int j = 0;
     91      private Spot[] dup = null;
     92     
     93      public boolean hasNext()
     94      {
     95        j++;
     96        if (j >= size())
     97        {
     98          i++;
     99          j = i+1;
     100        }
     101        dup =  i < size() && j < size() ? new Spot[] {get(i), get(j)} : null;
     102        return dup != null;
     103      }
    127104
    128   @Override
    129   public String toString()
     105      public Spot[] next()
     106      {
     107        if (dup != null)
     108        {
     109          return dup;
     110        }
     111        throw new NoSuchElementException();
     112      }
     113
     114      public void remove()
     115      {
     116        throw new UnsupportedOperationException();
     117      }
     118    };
     119  }
     120 
     121  public static float getReplicateRatio(Spot s1, Spot s2)
    130122  {
    131     return "[" + asTabString() + "]";
     123    return s1.getRatio() / s2.getRatio();
     124  }
     125 
     126  public static float getReplicateM(Spot s1, Spot s2)
     127  {
     128    return (float) (Math.log(getReplicateRatio(s1, s2)) / Math.log(2));
    132129  }
    133130}
  • trunk/se/lu/onk/ReplicateError/src/replicateerror/ReplicateError.java

    r49 r80  
    2020
    2121import java.io.File;
     22import java.io.FileNotFoundException;
    2223import java.io.IOException;
    2324import java.io.PrintStream;
     25import java.util.ArrayList;
     26import java.util.Collection;
    2427import java.util.Collections;
     28import java.util.HashMap;
     29import java.util.Iterator;
    2530import java.util.List;
    2631
     
    116121  protected float median(List<Float> l)
    117122  {
     123    if (l.size() < 1) return Float.NaN;
    118124    Collections.sort(l);
    119125    float n = l.get(((l.size())/2)-1);
     
    155161    }
    156162  }
     163 
     164  protected void printDuplicates(Collection<Replicate> replicates, String filename) throws FileNotFoundException
     165  {
     166    PrintStream out = new PrintStream(new File("data", filename));
     167    for(Replicate r : replicates)
     168    {
     169      Iterator<Spot[]> i = r.duplicateIterator();
     170      while (i.hasNext())
     171      {
     172        Spot[] d = i.next();
     173        out.println(d[0].getRatio()+"\t"+d[1].getRatio());
     174      }
     175    }
     176    out.close();
     177  }
     178
     179  protected void printSpots(int assay, HashMap<Integer,Replicate> values)
     180  {
     181    for (Integer reporter : values.keySet())
     182    {
     183      Replicate r = values.get(reporter);
     184      Spot s = r.getAssaySpot(assay);
     185      for (int i = 0; s != null && i < s.getPos().size(); i++)
     186      {
     187        System.out.println(s.getPos(i)+"\t"+reporter+"\t"+s.getInt1(i)+"\t"+s.getInt2(i));
     188      }
     189    }
     190  }
     191 
     192  protected float[] caluculateABR(Collection<Replicate> replicates)
     193  {
     194    //TODO compare with function in net.sf.basedb.plugins.LowessNormalization
     195    float[] result = new float[3]; // a b r
     196
     197    float meanX = 0;
     198    float meanY = 0;
     199    float ssxx = 0;
     200    float ssyy = 0;
     201    float ssxy = 0;
     202
     203    for (Replicate r : replicates)
     204    {
     205      Iterator<Spot[]> i = r.duplicateIterator();
     206      while(i.hasNext())
     207      {
     208        Spot[] d = i.next();
     209        float m1 = d[0].getM();
     210        float m2 = d[1].getM();
     211       
     212        meanX += m1;
     213        meanY += m2;
     214        ssyy += Math.pow(m2, 2);
     215        ssxx += Math.pow(m1, 2);
     216        ssxy += m1 * m2;
     217      }
     218    }
     219    meanX /= replicates.size();
     220    meanY /= replicates.size();
     221    ssxx = ssxx - replicates.size() * meanX * meanX;
     222    ssyy = ssyy - replicates.size() * meanY * meanY;
     223    ssxy = ssxy - replicates.size() * meanX * meanY;
     224   
     225    result[1] = ssxy / ssxx;
     226    result[0] = meanY - result[1] * meanX;
     227    result[2] = (float) Math.sqrt((ssxy * ssxy) / (ssxx * ssyy));
     228   
     229    return result;
     230  }
     231
     232  protected List<Float> getMList(Collection<Replicate> replicates)
     233  {
     234    List<Float> l = new ArrayList<Float>();
     235    for (Replicate r : replicates)
     236    {
     237      Iterator<Spot[]> i = r.duplicateIterator();
     238      while (i.hasNext())
     239      {
     240        Spot[] d = i.next();
     241        l.add(Replicate.getReplicateM(d[0], d[1]));
     242      }
     243    }
     244    return l;
     245  }
    157246}
  • trunk/se/lu/onk/ReplicateError/src/replicateerror/WithinAssays/ReplicateErrorWA.java

    r52 r80  
    2222import java.io.IOException;
    2323import java.io.PrintStream;
    24 import java.util.ArrayList;
    2524import java.util.HashMap;
    2625import java.util.Iterator;
     
    3332import replicateerror.Replicate;
    3433import replicateerror.ReplicateError;
     34import replicateerror.Spot;
    3535import replicateerror.AcrossAssays.HTML;
    3636
    3737public class ReplicateErrorWA extends ReplicateError
    3838{
    39   private HashMap<String, String> assayName;
     39  private HashMap<Integer, String> assayName;
    4040
    4141
     
    4343  {
    4444    super();
    45     assayName = new HashMap<String, String>();
     45    assayName = new HashMap<Integer, String>();
    4646    File dataDir = new File("data");
    4747    dataDir.mkdir();
     
    6161      while ((vals = bfr.readDataRow()) != null)
    6262      {
    63         assayName.put(vals[idCol], vals[nameCol]);
     63        assayName.put(new Integer(vals[idCol]), vals[nameCol]);
    6464        groupsFile.println(vals[nameCol]);
    6565      }
     
    7878    List<String> columns = section.findFieldList("columns");
    7979    List<String> assayFields = section.findFieldList("assayFields");
    80     List<String> assays = section.findFieldList("assays");
     80    List<Integer> assays = section.findFieldIntList("assays");
    8181
    8282    int posCol = columns.indexOf("position");
     
    8686    int int2Col = assayFields.indexOf("intensity2");
    8787
    88     HashMap<String, Integer> assayColumns = new HashMap<String, Integer>();
     88    HashMap<Integer, Integer> assayColumns = new HashMap<Integer, Integer>();
    8989    for (int i = 0; i < assays.size(); i++)
    9090    {
     
    102102    {
    103103      HTML.openPlotsTable(center.toString());
    104       for (String assay : assays)
     104      for (Integer assay : assays)
    105105      {
    106         spotSection.setHeader("assays", assay);
    107         System.out.println(spotSection);
    108106        HashMap<Integer, Replicate> replicates = new HashMap<Integer, Replicate>();
     107        HashMap<Integer, Replicate> singletons = new HashMap<Integer, Replicate>();
    109108       
    110109        String[] vals;
    111110        while ((vals = bfr.readDataRow()) != null)
    112111        {
    113           int reporter = new Integer(vals[repCol]);
    114           int position = new Integer(vals[posCol]);
     112          Integer reporter = new Integer(vals[repCol]);
    115113
    116114          Replicate replicate = replicates.get(reporter);
    117115          if (replicate == null)
    118116          {
    119             replicate = new Replicate(position, reporter);
     117            replicate = new Replicate();
    120118          }
    121119          try
    122120          {
     121            int position = new Integer(vals[posCol]);
    123122            float int1 = new Float(vals[assayColumns.get(assay) + int1Col]);
    124123            float int2 = new Float(vals[assayColumns.get(assay) + int2Col]);
    125124            if (int1 > 0 && int2 > 0)
    126125            {
    127               replicate.addIntensity(int1, int2);
     126              Spot s = new Spot(new Integer(assay));
     127              s.add(position, int1, int2);
     128              replicate.add(s);
    128129              replicates.put(reporter, replicate);
    129130            }
     
    134135       
    135136        // remove unusable replicates
    136         Iterator<Replicate> it = replicates.values().iterator();
     137        Iterator<Integer> it = replicates.keySet().iterator();
    137138        while (it.hasNext())
    138139        {
    139           Replicate r = it.next();
    140           if (leaveSingletons && r.getSize() == 1)
    141           {
    142             System.out.println(r.asTabString());
     140          Integer reporter = it.next();
     141          Replicate r = replicates.get(reporter);
     142          if (leaveSingletons && r.size() == 1)
     143          {
     144            singletons.put(reporter, r);
    143145            it.remove();
    144146          }
    145           else if (r.getSize() != 2)
    146           {
    147             it.remove();
    148           }
    149147          else
    150148          {
    151             R.replica1Range(r.getM(0));
    152             R.replica2Range(r.getM(1));
    153             R.replicaMRange(r.getReplicateM(0, 1));
     149            Iterator<Spot[]> dupI = r.duplicateIterator();
     150            while (dupI.hasNext())
     151            {
     152              Spot[] d = dupI.next();
     153              R.replica1Range(d[0].getM());
     154              R.replica2Range(d[1].getM());
     155              R.replicaMRange(Replicate.getReplicateM(d[0], d[1]));
     156            }
    154157          }
    155158        }
     
    159162        // calculate mean or median
    160163        float averageBefore;
    161         List<Float> mList = getMList(replicates);
     164        List<Float> mList = getMList(replicates.values());
    162165        if (center == Center.median)
    163166        {
     
    171174        float sdBefore = standardDiviation(mList, mean(mList));
    172175
    173         R.setABRBefore(assayName.get(assay), caluculateABR(replicates));
     176        R.setABRBefore(assayName.get(assay), caluculateABR(replicates.values()));
    174177       
    175178        // print result
    176         PrintStream allReplicates = new PrintStream(new File("data", assayName.get(assay) + ".data"));
    177         PrintStream goodReplicates = new PrintStream(new File("data", assayName.get(assay) + "good.data"));
    178        
    179         // filter replicates abs(M - mean) against 'sdLimit' number of sd's
    180         it = replicates.values().iterator();
    181         while (it.hasNext())
    182         {
    183           Replicate r = it.next();
    184           allReplicates.println(r.getRatio(0) + "\t" + r.getRatio(1));
    185           float m = r.getReplicateM(0, 1);
    186          
    187           if (Math.abs(m - averageBefore) < sdLimit * sdBefore)
    188           {
    189             for (int i = 0; i < r.getSize(); i++)
    190             {
    191               System.out.printf("%d\t%d\t%f\t%f%n", r.getPosition(), r.getReporter(), r.getInt1(i), r.getInt2(i));
    192             }
    193             goodReplicates.println(r.getRatio(0) + "\t" + r.getRatio(1));
    194           }
    195           else
    196           {
    197             it.remove();
    198           }
    199         }
    200         System.out.println();
     179        printDuplicates(replicates.values(), assayName.get(assay) + ".data");
     180       
     181        // filter replicates abs(M - mean) against 'sdLimit' number of sd's
     182        for (Replicate r : replicates.values())
     183        {
     184          r.filter(averageBefore, sdLimit * sdBefore);
     185        }
     186        printDuplicates(replicates.values(), assayName.get(assay) + "good.data");
    201187       
    202188        // calculate mean
    203         mList = getMList(replicates);
     189        mList = getMList(replicates.values());
    204190        float averageAfter;
    205191        if (center == Center.median)
     
    214200        float sdAfter = standardDiviation(mList, mean(mList));
    215201       
    216         R.setABRAfter(assayName.get(assay), caluculateABR(replicates));
     202        R.setABRAfter(assayName.get(assay), caluculateABR(replicates.values()));
    217203        HTML.addPlotsTable(assayName.get(assay), averageBefore, sdBefore, nbrBefore, averageAfter, sdAfter, replicates.size());
     204
     205        // print to stdout
     206        spotSection.setHeader("assays", assay);
     207        System.out.println(spotSection);
     208        printSpots(assay, replicates);
     209        printSpots(assay, singletons);
     210        System.out.println();
    218211       
    219212        bfr.resetDataPosition(section);
     
    228221    }
    229222  }
    230 
    231   private float[] caluculateABR(HashMap<Integer, Replicate> replicates)
    232   {
    233     float[] result = new float[3]; // a b r
    234    
    235     float meanX = 0;
    236     float meanY = 0;
    237     float ssxx = 0;
    238     float ssyy = 0;
    239     float ssxy = 0;
    240    
    241     for (Replicate r : replicates.values())
    242     {
    243       float m1 = r.getM(0);
    244       float m2 = r.getM(1);
    245      
    246       meanX += m1;
    247       meanY += m2;
    248       ssxx += Math.pow(m1, 2);
    249       ssyy += Math.pow(m2, 2);
    250       ssxy += m1 * m2;
    251     }
    252     meanX /= replicates.size();
    253     meanY /= replicates.size();
    254     ssxx = ssxx - replicates.size() * meanX * meanX;
    255     ssyy = ssyy - replicates.size() * meanY * meanY;
    256     ssxy = ssxy - replicates.size() * meanX * meanY;
    257    
    258     result[1] = ssxy/ssxx;
    259     result[0] = meanY - result[1] * meanX;
    260     result[2] = (float) Math.sqrt((ssxy*ssxy)/(ssxx*ssyy));
    261    
    262     return result;
    263   }
    264 
    265   private List<Float> getMList(HashMap<Integer, Replicate> replicates)
    266   {
    267 
    268     List<Float> l = new ArrayList<Float>();
    269     for (Replicate r : replicates.values())
    270     {
    271       l.add(r.getReplicateM(0, 1));
    272     }
    273     return l;
    274   }
    275223}
Note: See TracChangeset for help on using the changeset viewer.