Changeset 187

Show
Ignore:
Timestamp:
10-02-10 16:09:52 (4 years ago)
Author:
keesvb
Message:

changed definition of clean data layer, implemented it for the clinical data module, added demonstration to the sandbox

Location:
trunk
Files:
1 removed
6 modified
1 copied

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/conf/BootStrap.groovy

    r186 r187  
    295295                                name: 'LDL', 
    296296                                unit: 'mg/dL', 
    297                                 type: dbnp.clinicaldata.ClinicalMeasurementType.NUMBER, 
     297                                type: dbnp.data.FeatureType.QUANTITATIVE, 
    298298                                referenceValues: '100 mg/dL', 
    299299                                detectableLimit: 250, 
     
    304304                                name: 'HDL', 
    305305                                unit: 'mg/dL', 
    306                                 type: dbnp.clinicaldata.ClinicalMeasurementType.NUMBER, 
     306                                type: dbnp.data.FeatureType.QUANTITATIVE, 
    307307                                referenceValues: '50 mg/dL', 
    308308                                detectableLimit: 100, 
  • trunk/grails-app/controllers/SandboxController.groovy

    r186 r187  
    11import dbnp.studycapturing.* 
     2import dbnp.clinicaldata.ClinicalFloatData 
     3import dbnp.clinicaldata.ClinicalMeasurement 
    24 
    35// The sandbox is meant for internal communication over code examples etc. 
    46 
    57class SandboxController { 
     8 
     9        def clinicalDataLayerService 
    610 
    711        def index = { 
     
    2226 
    2327                //Let's get a certain field for a certain subject 
    24                 def subject = Subject.findByName('A1') 
     28                /*def subject = st.subjects.get(1) 
     29 
     30                if (subject) { 
    2531                println st.template.getSubjectFieldType('Age') 
    2632                println subject.getFieldValue('Genotype') 
     
    2834                println subject.getFieldValue('Genotype') 
    2935                subject.setFieldValue('name','hallo') 
    30                 println subject.name 
     36                println subject.name }*/ 
    3137 
    32                 println Study.get(2).giveSamples()*.name 
    33          
     38 
     39                // Demonstration of querying mechanism 
     40                println clinicalDataLayerService.getFeaturesQuantitative(1) 
     41                clinicalDataLayerService.getDataQuantitative('LDL',1,['A1_B','A3_B'] as String[]) 
    3442 
    3543                // Specify which variables we want to be available in the controller (implicit return statement) 
    3644                [fields: f, subjects: st.subjects] 
     45        } 
    3746} 
    38 } 
  • trunk/grails-app/domain/dbnp/clinicaldata/ClinicalMeasurement.groovy

    r186 r187  
    11package dbnp.clinicaldata 
     2 
     3import dbnp.data.FeatureType 
    24 
    35class ClinicalMeasurement 
    46 extends dbnp.data.FeatureBase { 
    57 
    6         ClinicalMeasurementType type 
     8        // For now, let's assume that quantitative values are stored as float, 
     9        // and qualitative values as string 
     10        // We can always add an additional ClinicalMeasurementType datatype (FLOAT, INTEGER etc.) later (as was here until rev 186) 
     11 
    712        String referenceValues 
    813        float detectableLimit 
     
    1318 
    1419        static constraints = { 
     20                name(unique:true) 
    1521                referenceValues(nullable: true, blank: true) 
    1622                detectableLimit(nullable: true) 
    1723                correctionMethod(nullable: true, blank: true) 
    1824        } 
     25 
     26        Map getValues(long assayID, String[] sampleIDs) { 
     27                FeatureType featureType = type 
     28                switch(featureType) { 
     29                        case FeatureType.QUANTITATIVE: 
     30                                def values = ClinicalFloatData.withCriteria { 
     31                                        assay { eq("id",assayID) } 
     32                                        eq("measurement",this) 
     33                                        'in'("sample",sampleIDs) 
     34                                } 
     35                                def result = new HashMap<String,Float>(); 
     36                                values.each { 
     37                                        result.put(it.sample,it.value) 
     38                                } 
     39                                return result 
     40                        default: 
     41                                throw new NoSuchFieldException("Feature type ${featureType} not supported") 
     42                } 
     43        } 
    1944} 
  • trunk/grails-app/domain/dbnp/data/FeatureBase.groovy

    r162 r187  
    55        String name 
    66        String unit 
     7        FeatureType type 
    78 
    89        static hasMany = [ 
  • trunk/grails-app/domain/dbnp/data/FeatureType.groovy

    r186 r187  
    1 package dbnp.studycapturing 
     1package dbnp.data 
    22 
    33/** 
    44 * Enum describing the different assay types (aka omics submodules). 
    55 */ 
    6 public enum AssayType { 
    7     TRANSCRIPTOMICS('Transcriptomics'), 
    8     METABOLOMICS('Metabolomics'), 
    9     CLINICAL_DATA('Clinical data') 
     6public enum FeatureType { 
     7    QUANTITATIVE('Quantitative'), 
     8    QUALITATIVE('Qualitative'), 
     9    PAIRED('Paired'), 
     10    DIFFERENTIAL('Differential') 
    1011 
    1112    String name 
    1213 
    13     AssayType(String name) { 
     14    FeatureType(String name) { 
    1415     this.name = name 
    1516    } 
    1617 
    1718    static list() { 
    18      [TRANSCRIPTOMICS, METABOLOMICS, CLINICAL_DATA] 
     19     [QUANTITATIVE, QUALITATIVE, PAIRED, DIFFERENTIAL] 
    1920    } 
    2021 
  • trunk/grails-app/services/dbnp/clinicaldata/ClinicalDataLayerService.groovy

    r106 r187  
    55        boolean transactional = false 
    66 
    7         String getAssayDescription(long assayID) { 
    8                 return ""; 
     7        Map getDataQuantitative(String feature, long assayID, String[] sampleIDs) { 
     8                def measurement = ClinicalMeasurement.findByName(feature) 
     9                if (!measurement) throw new NoSuchFieldException("Feature ${feature} not found") 
     10                measurement.getValues(assayID,sampleIDs) 
    911        } 
    1012 
    11         String[] getFeatureNames(long assayID) { 
    12                 return new String[0]; 
    13         } 
    14  
    15         Map getFeatureData(long assayID, long[] sampleIDs) { 
    16                 return null; 
    17         } 
    18  
    19         Map getFeatureDataDifferential(long assayID, long[] sampleIDs1, long[] sampleIDs2) { 
    20                 return null; 
     13        String[] getFeaturesQuantitative(long assayID) { 
     14                return ClinicalAssayInstance.get(assayID).assay.measurements*.name; 
    2115        } 
    2216} 
  • trunk/src/java/dbnp/data/CleanDataLayer.java

    r106 r187  
    88public interface CleanDataLayer { 
    99 
    10         public String getAssayDescription(long assayID); 
    11         public String[] getFeatureNames(long assayID); 
    12         public Map getFeatureData(long assayID, long[] sampleIDs); 
    13         public Map getFeatureDataDifferential(long assayID, long[] sampleIDs1, long[] sampleIDs2); 
     10        /** 
     11         * Get the names of all quantitative features that are available for a certain assay 
     12         * @param assayID the module internal ID for the assay 
     13         * @return 
     14         */ 
     15        public String[] getFeaturesQuantitative(long assayID); 
     16 
     17        /** 
     18         * Get the data for a quantitative feature for a certain assay for a certain set of samples 
     19         * @param feature 
     20         * @param assayID 
     21         * @param sampleIDs 
     22         * @return 
     23         */ 
     24        public Map getDataQuantitative(String feature, long assayID, String[] sampleIDs); 
    1425 
    1526}