source: trunk/grails-app/conf/BootStrap.groovy @ 454

Last change on this file since 454 was 454, checked in by roberth, 12 years ago

Improved study list to be able to handle one or more studies. Also improved performance issues with Subject and Sample classes. I have set the domainFields property to a static property, filled it in the class description and attached an ontology to it in the bootstrap (because it can't be done in the class description). It might not be the prettiest solution, it does improve the performance of the study detail page and study comparison with 90%.

  • Property svn:keywords set to Author Rev Date
File size: 28.3 KB
Line 
1import dbnp.studycapturing.*
2
3import dbnp.data.Ontology
4import dbnp.data.Term
5import org.codehaus.groovy.grails.commons.GrailsApplication
6
7/**
8 * Application Bootstrapper
9 * @Author Jeroen Wesbeek
10 * @Since 20091021
11 *
12 * Revision information:
13 * $Rev: 454 $
14 * $Author: roberth $
15 * $Date: 2010-05-21 08:04:49 +0000 (vr, 21 mei 2010) $
16 */
17class BootStrap {
18        def init = {servletContext ->
19                // define timezone
20                System.setProperty('user.timezone', 'CET')
21
22                // Ontologies must be connected to the templatefields in runtime
23                // because the Ontology.findByNcboId is not available otherwise
24                TemplateEntity.getField( Subject.domainFields, 'species' ).ontologies = [Ontology.findByNcboId(1132)]
25                TemplateEntity.getField( Sample.domainFields, 'material' ).ontologies = [Ontology.findByNcboId(1005)]
26
27                // we could also check if we are in development by GrailsUtil.environment == GrailsApplication.ENV_DEVELOPMENT
28                if (Study.count() == 0) {
29                        println ".development bootstrapping...";
30
31                        // add Subject>species ontology
32                        println ".adding NCBI species ontology"
33                        def speciesOntology = new Ontology(
34                                name: 'NCBI organismal classification',
35                                description: 'A taxonomic classification of living organisms and associated artifacts for their controlled description within the context of databases.',
36                                url: 'http://www.ncbi.nlm.nih.gov/Taxonomy/taxonomyhome.html/',
37                                versionNumber: '1.2',
38                                ncboId: '1132',
39                                ncboVersionedId: '38802'
40                        ).with { if (!validate()) { errors.each { println it} } else save()}
41
42                        // add Sample>material ontology
43                        println ".adding BRENDA source material ontology"
44                        def brendaOntology = new Ontology(
45                                name: 'BRENDA tissue / enzyme source',
46                                description: 'A structured controlled vocabulary for the source of an enzyme. It comprises terms for tissues, cell lines, cell types and cell cultures from uni- and multicellular organisms.',
47                                url: 'http://www.brenda-enzymes.info',
48                                versionNumber: '1.3',
49                                ncboId: '1005',
50                                ncboVersionedId: '40643'
51                        ).with { if (!validate()) { errors.each { println it} } else save()}
52
53                        // add NCI ontology which is used in Mouse genotype template field
54                        def nciOntology = new Ontology(
55                                name: 'NCI Thesaurus',
56                                description: 'A vocabulary for clinical care, translational and basic research, and public information and administrative activities.',
57                                url: 'http://ncicb.nci.nih.gov/core/EVS',
58                                versionNumber: '10.01',
59                                ncboId: '1032',
60                                ncboVersionedId: '42693'
61                        ).with { if (!validate()) { errors.each { println it} } else save()}
62                       
63                        // add Terms
64                        println ".adding mouse term"
65                        def mouseTerm = new Term(
66                                name: 'Mus musculus',
67                                ontology: speciesOntology,
68                                accession: '10090'
69                        ).with { if (!validate()) { errors.each { println it} } else save()}
70                        println ".adding human term"
71                        def humanTerm = new Term(
72                                name: 'Homo sapiens',
73                                ontology: speciesOntology,
74                                accession: '9606'
75                        ).with { if (!validate()) { errors.each { println it} } else save()}
76                        def arabTerm = new Term(
77                                name: 'Arabidopsis thaliana',
78                                ontology: speciesOntology,
79                                accession: '3702'
80                        ).with { if (!validate()) { errors.each { println it} } else save()}
81
82                        def bloodTerm = new Term(
83                                name: 'blood plasma',
84                                ontology: brendaOntology,
85                                accession: 'BTO:0000131'
86                        ).with { if (!validate()) { errors.each { println it} } else save()}
87
88                        def c57bl6Term = new Term(
89                                name: 'C57BL/6 Mouse',
90                                ontology: nciOntology,
91                                accession: 'C14424'
92                        ).with { if (!validate()) { errors.each { println it} } else save()}
93
94                        // Create a few persons, roles and Affiliations
95                        println ".adding persons, roles and affiliations"
96                        def affiliation1 = new PersonAffiliation(
97                            institute: "Science Institute NYC",
98                            department: "Department of Mathematics"
99                        ).save();
100                        def affiliation2 = new PersonAffiliation(
101                            institute: "InfoStats GmbH, Hamburg",
102                            department: "Life Sciences"
103                        ).save();
104                        def role1 = new PersonRole(
105                            name: "Principal Investigator"
106                        ).save();
107                        def role2 = new PersonRole(
108                            name: "Statician"
109                        ).save();
110
111                        // Create persons
112                        def person1 = new Person(
113                            lastName: "Scientist",
114                            firstName: "John",
115                            gender: "Male",
116                            initials: "J.R.",
117                            email: "john@scienceinstitute.com",
118                            phone: "1-555-3049",
119                            address: "First street 2,NYC"
120                        )
121                        .addToAffiliations( affiliation1 )
122                        .addToAffiliations( affiliation2 )
123                        .save();
124
125                        def person2 = new Person(
126                            lastName: "Statician",
127                            firstName: "Jane",
128                            gender: "Female",
129                            initials: "W.J.",
130                            email: "jane@statisticalcompany.de",
131                            phone: "49-555-8291",
132                            address: "Dritten strasse 38, Hamburg, Germany"
133                        )
134                        .addToAffiliations( affiliation2 )
135                        .save();
136
137                        // Create 30 persons to test pagination
138                        def personCounter = 1;
139                        30.times { new Person( firstName: "Person #${personCounter}", lastName: "Testperson", email: "email${personCounter++}@testdomain.com" ).save() }
140
141                        // Create a few publications
142                        println ".adding publications"
143                        def publication1 = new Publication(
144                            title: "Postnatal development of hypothalamic leptin receptors",
145                            authorsList: "Cottrell EC, Mercer JG, Ozanne SE.",
146                            pubMedID: "20472140",
147                            comments: "Not published yet",
148                            DOI: "unknown"
149                        )
150                        .save();
151
152                        def publication2 = new Publication(
153                            title: "Induction of regulatory T cells decreases adipose inflammation and alleviates insulin resistance in ob/ob mice",
154                            authorsList: "Ilan Y, Maron R, Tukpah AM, Maioli TU, Murugaiyan G, Yang K, Wu HY, Weiner HL.",
155                            pubMedID: "20445103",
156                            comments: "",
157                            DOI: ""
158                        )
159                        .save();
160
161            // Create templates
162
163                        def genderField = new TemplateField(
164                                name: 'Gender',type: TemplateFieldType.STRINGLIST,
165                                listEntries: [new TemplateFieldListItem(name:'Male'),new TemplateFieldListItem(name: 'Female')])
166                        .with { if (!validate()) { errors.each { println it} } else save()}
167
168                        def ageField = new TemplateField(
169                                name: 'Age (years)',type: TemplateFieldType.INTEGER,unit: 'years')
170                        .with { if (!validate()) { errors.each { println it} } else save()}
171
172                        def genotypeField = new TemplateField(
173                                name: 'Genotype', type: TemplateFieldType.ONTOLOGYTERM)
174                        .with { if (!validate()) { errors.each { println it} } else save()}
175
176                        def genotypeTypeField = new TemplateField(
177                                name: 'Genotype type',type: TemplateFieldType.STRINGLIST,
178                                listEntries: [new TemplateFieldListItem(name:'wildtype'),
179                                        new TemplateFieldListItem(name:'transgenic'),
180                                        new TemplateFieldListItem(name:'knock-out'),
181                                        new TemplateFieldListItem(name:'knock-in')])
182                        .with { if (!validate()) { errors.each { println it} } else save()}
183
184
185                        // Nutritional study template
186
187                        println ".adding academic study template..."
188                        def studyTemplate = new Template(
189                                name: 'Academic study', entity: dbnp.studycapturing.Study)
190                                .addToFields(new TemplateField(name: 'Description',type: TemplateFieldType.TEXT))
191                                .addToFields(new TemplateField(name: 'Study code',type: TemplateFieldType.STRING, preferredIdentifier:true))
192                                .addToFields(new TemplateField(name: 'Objectives',type: TemplateFieldType.TEXT))
193                                .addToFields(new TemplateField(name: 'Consortium',type: TemplateFieldType.STRING))
194                                .addToFields(new TemplateField(name: 'Cohort name',type: TemplateFieldType.STRING))
195                                .addToFields(new TemplateField(name: 'Time zone',type: TemplateFieldType.STRING))
196                                .addToFields(new TemplateField(name: 'Responsible scientist',type: TemplateFieldType.STRING))
197                                .addToFields(new TemplateField(name: 'Lab id',type: TemplateFieldType.STRING))
198                                .addToFields(new TemplateField(name: 'Institute',type: TemplateFieldType.STRING))
199                        .with { if (!validate()) { errors.each { println it} } else save()}
200
201                        // Mouse template
202                        println ".adding mouse subject template..."
203                        def mouseTemplate = new Template(
204                                name: 'Mouse', entity: dbnp.studycapturing.Subject)
205                        .addToFields(new TemplateField(
206                                name: 'Strain', type: TemplateFieldType.ONTOLOGYTERM))
207                        .addToFields(genotypeField)
208                        .addToFields(genotypeTypeField)
209                        .addToFields(genderField)
210                        .addToFields(new TemplateField(
211                                name: 'Age (weeks)', type: TemplateFieldType.INTEGER, unit: 'weeks'))
212                        .addToFields(new TemplateField(
213                                name: 'Age type',type: TemplateFieldType.STRINGLIST,
214                                listEntries: [new TemplateFieldListItem(name:'postnatal'),new TemplateFieldListItem(name:'embryonal')]))
215                        .addToFields(new TemplateField(
216                                name: 'Cage',type: TemplateFieldType.STRING))
217                        .addToFields(new TemplateField(
218                                name: '#Mice in cage',type: TemplateFieldType.INTEGER))
219                        .addToFields(new TemplateField(
220                                name: 'Litter size',type: TemplateFieldType.INTEGER))
221                        .addToFields(new TemplateField(
222                                name: 'Weight (g)', type: TemplateFieldType.DOUBLE, unit: 'gram'))
223                        .with { if (!validate()) { errors.each { println it} } else save()}
224
225                        // Human template
226                        println ".adding human subject template..."
227                        def humanTemplate = new Template(
228                                name: 'Human', entity: dbnp.studycapturing.Subject)
229                        .addToFields(genderField)
230                        .addToFields(ageField)
231                        .addToFields(new TemplateField(
232                                name: 'DOB',type: TemplateFieldType.DATE))
233                        .addToFields(new TemplateField(
234                                name: 'Height',type: TemplateFieldType.DOUBLE, unit: 'm'))
235                        .addToFields(new TemplateField(
236                                name: 'Weight (kg)',type: TemplateFieldType.DOUBLE, unit: 'kg'))
237                        .addToFields(new TemplateField(
238                                name: 'BMI',type: TemplateFieldType.DOUBLE, unit: 'kg/m2'))
239                        .addToFields(new TemplateField(
240                                name: 'Race',type: TemplateFieldType.STRING))
241                        .addToFields(new TemplateField(
242                                name: 'Waist circumference',type: TemplateFieldType.FLOAT, unit: 'cm'))
243                        .addToFields(new TemplateField(
244                                name: 'Hip circumference',type: TemplateFieldType.FLOAT, unit: 'cm'))
245                        .addToFields(new TemplateField(
246                                name: 'Systolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg'))
247                        .addToFields(new TemplateField(
248                                name: 'Diastolic blood pressure',type: TemplateFieldType.FLOAT, unit: 'mmHg'))
249                        .addToFields(new TemplateField(
250                                name: 'Heart rate',type: TemplateFieldType.FLOAT, unit: 'beats/min'))
251                        .addToFields(new TemplateField(
252                                name: 'Run-in-food',type: TemplateFieldType.TEXT))
253                        .with { if (!validate()) { errors.each { println it} } else save()}
254
255
256                        def sampleDescriptionField = new TemplateField(
257                                name: 'Description',type: TemplateFieldType.TEXT)
258                        .with { if (!validate()) { errors.each { println it} } else save()}
259                        def sampleTypeField = new TemplateField(
260                                name: 'SampleType',type: TemplateFieldType.STRING)
261                        .with { if (!validate()) { errors.each { println it} } else save()}
262                        def sampleProtocolField = new TemplateField(
263                                name: 'SampleProtocol',type: TemplateFieldType.STRING)
264                        .with { if (!validate()) { errors.each { println it} } else save()}
265                        def sampleVialTextField = new TemplateField(
266                                name: 'Text on vial',type: TemplateFieldType.STRING)
267                        .with { if (!validate()) { errors.each { println it} } else save()}
268
269                        // Human sample template
270                        println ".adding human sample template..."
271                        def humanSampleTemplate = new Template(
272                                name: 'Human tissue sample', entity: dbnp.studycapturing.Sample)
273                        .addToFields(sampleDescriptionField)
274                        .addToFields(sampleTypeField)
275                        .addToFields(sampleProtocolField)
276                        .addToFields(sampleVialTextField)
277                        .with { if (!validate()) { errors.each { println it} } else save()}
278
279                        //Plant template
280                        println ".adding plant template..."
281                        def plantTemplate = new Template(
282                                name: 'Plant template', entity: dbnp.studycapturing.Subject)
283                        .addToFields(new TemplateField(
284                                name: 'Variety', type: TemplateFieldType.STRING))
285                        .addToFields(new TemplateField(
286                                name: 'Ecotype', type: TemplateFieldType.STRING))
287                        .addToFields(genotypeField)
288                        .addToFields(genotypeTypeField)
289                        .addToFields(new TemplateField(
290                                name: 'Growth location', type: TemplateFieldType.STRINGLIST,
291                                listEntries: [new TemplateFieldListItem(name:'Greenhouse'),new TemplateFieldListItem(name: 'Field')]))
292                        .addToFields(new TemplateField(
293                                name: 'Room', type: TemplateFieldType.STRING,
294                                comment: 'Chamber number in case of Greenhouse'))
295                        .addToFields(new TemplateField(
296                                name: 'Position X', type: TemplateFieldType.FLOAT))
297                        .addToFields(new TemplateField(
298                                name: 'Position Y', type: TemplateFieldType.FLOAT))
299                        .addToFields(new TemplateField(
300                                name: 'Block', type: TemplateFieldType.STRING))
301                        .addToFields(new TemplateField(
302                                name: 'Temperature at day', type: TemplateFieldType.FLOAT))
303                        .addToFields(new TemplateField(
304                                name: 'Temperature at night', type: TemplateFieldType.FLOAT))
305                        .addToFields(new TemplateField(
306                                name: 'Photo period', type: TemplateFieldType.STRING))
307                        .addToFields(new TemplateField(
308                                name: 'Light intensity', type: TemplateFieldType.STRING))
309                        .addToFields(new TemplateField(
310                                name: 'Start date', type: TemplateFieldType.DATE))
311                        .addToFields(new TemplateField(
312                                name: 'Harvest date', type: TemplateFieldType.DATE))
313                        .addToFields(new TemplateField(
314                                name: 'Growth type', type: TemplateFieldType.STRINGLIST,
315                                listEntries: [new TemplateFieldListItem(name:'Standard'),new TemplateFieldListItem(name: 'Experimental')]))
316                        .addToFields(new TemplateField(
317                                name: 'Growth protocol', type: TemplateFieldType.TEXT))
318                        .addToFields(new TemplateField(
319                                name: 'Harvest delay', type: TemplateFieldType.TEXT))
320                        .with { if (!validate()) { errors.each { println it} } else save()}
321
322                        println ".adding plant sample template..."
323                        def plantSampleTemplate = new Template(
324                                name: 'Plant sample', entity: dbnp.studycapturing.Sample)
325                        .addToFields(sampleDescriptionField)
326                        .addToFields(sampleTypeField)
327                        .addToFields(sampleProtocolField)
328                        .addToFields(sampleVialTextField)
329                        .with { if (!validate()) { errors.each { println it} } else save()}
330
331
332                        // Event templates
333                        def dietTreatmentTemplate = new Template(
334                                name: 'Diet treatment', entity: dbnp.studycapturing.Event)
335                        .addToFields(sampleDescriptionField)
336                        .addToFields(new TemplateField(
337                                name: 'Diet', type: TemplateFieldType.STRINGLIST,
338                                listEntries: [new TemplateFieldListItem(name:'10% fat (palm oil)'),new TemplateFieldListItem(name: '45% fat (palm oil)')]))
339                        .with { if (!validate()) { errors.each { println it} } else save()}
340
341                        def boostTreatmentTemplate = new Template(
342                                name: 'Boost treatment', entity: dbnp.studycapturing.Event)
343                        .addToFields(sampleDescriptionField)
344                        .addToFields(new TemplateField(
345                                name: 'Compound', type: TemplateFieldType.STRING,
346                                listEntries: [new TemplateFieldListItem(name:'Vehicle'),new TemplateFieldListItem(name: 'Leptin')]))
347                        .with { if (!validate()) { errors.each { println it} } else save()}
348
349                        def fastingTreatment = new Template(
350                                 name: 'Fasting treatment',
351                                 description: 'Fasting Protocol NuGO PPSH',
352                                 entity: dbnp.studycapturing.Event)
353                         .addToFields(new TemplateField(
354                                 name: 'Fasting period',
355                                 type: TemplateFieldType.STRING))
356                         .with { if (!validate()) { errors.each { println it} } else save()}
357
358                        // SamplingEvent templates
359
360                        def liverSamplingEventTemplate = new Template(
361                                name: 'Liver extraction',
362                                description: 'Liver sampling for transcriptomics arrays',
363                                entity: dbnp.studycapturing.SamplingEvent)
364                        .addToFields(new TemplateField(
365                                name: 'Sample weight',
366                                unit: 'mg',
367                                type: TemplateFieldType.FLOAT))
368                        .with { if (!validate()) { errors.each { println it} } else save()}
369
370                        def bloodSamplingEventTemplate = new Template(
371                                name: 'Blood extraction',
372                                description: 'Blood extraction targeted at lipid assays',
373                                entity: dbnp.studycapturing.SamplingEvent)
374                        .addToFields(new TemplateField(
375                                name: 'Sample volume',
376                                unit: 'ml',
377                                type: TemplateFieldType.FLOAT))
378                        .with { if (!validate()) { errors.each { println it} } else save()}
379
380
381                        // Add example studies
382                        if (!(grails.util.GrailsUtil.environment == GrailsApplication.ENV_TEST)) {
383                                println ".adding NuGO PPS3 leptin example study..."
384                                def mouseStudy = new Study(
385                                        template: studyTemplate,
386                                        title:"NuGO PPS3 mouse study leptin module",
387                                        code:"PPS3_leptin_module",
388                                        researchQuestion:"Leptin etc.",
389                                        ecCode:"2007117.c",
390                                        startDate: Date.parse('yyyy-MM-dd','2007-12-11')
391                                )
392                                .with { if (!validate()) { errors.each { println it} } else save()}
393
394                                mouseStudy.setFieldValue('Description', "C57Bl/6 mice were fed a high fat (45 en%) or low fat (10 en%) diet after a four week run-in on low fat diet. After 1 week 10 mice that received a low fat diet were given an IP leptin challenge and 10 mice of the low-fat group received placebo injections. The same procedure was performed with mice that were fed the high-fat diet. After 4 weeks the procedure was repeated. In total 80 mice were culled." )
395                                mouseStudy.save()
396
397                                def evLF = new Event(
398                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
399                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
400                                        template: dietTreatmentTemplate
401                                )
402                                .setFieldValue( 'Diet','10% fat (palm oil)')
403                                .with { if (!validate()) { errors.each { println it} } else save()}
404
405                                def evHF = new Event(
406                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
407                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
408                                        template: dietTreatmentTemplate
409                                )
410                                .setFieldValue( 'Diet','45% fat (palm oil)' )
411                                .with { if (!validate()) { errors.each { println it} } else save()}
412
413                                def evBV = new Event(
414                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
415                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
416                                        template: boostTreatmentTemplate
417                                )
418                                .setFieldValue( 'Compound','Vehicle' )
419                                .with { if (!validate()) { errors.each { println it} } else save()}
420
421                                def evBL = new Event(
422                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
423                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
424                                        template: boostTreatmentTemplate
425                                )
426                                .setFieldValue( 'Compound','Leptin' )
427                                .with { if (!validate()) { errors.each { println it} } else save()}
428
429                                def evLF4 = new Event(
430                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
431                                        endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
432                                        template: dietTreatmentTemplate
433                                )
434                                .setFieldValue( 'Diet','10% fat (palm oil)')
435                                .with { if (!validate()) { errors.each { println it} } else save()}
436
437                                def evHF4 = new Event(
438                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
439                                        endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
440                                        template: dietTreatmentTemplate
441                                )
442                                .setFieldValue( 'Diet','45% fat (palm oil)' )
443                                .with { if (!validate()) { errors.each { println it} } else save()}
444
445                                def evBV4 = new Event(
446                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
447                                        endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
448                                        template: boostTreatmentTemplate
449                                )
450                                .setFieldValue( 'Compound','Vehicle' )
451                                .with { if (!validate()) { errors.each { println it} } else save()}
452
453                                def evBL4 = new Event(
454                                        startTime: Date.parse('yyyy-MM-dd','2008-01-07'),
455                                        endTime: Date.parse('yyyy-MM-dd','2008-02-04'),
456                                        template: boostTreatmentTemplate
457                                )
458                                .setFieldValue( 'Compound','Leptin' )
459                                .with { if (!validate()) { errors.each { println it} } else save()}
460
461                                def evS = new SamplingEvent(
462                                        startTime: Date.parse('yyyy-MM-dd','2008-01-14'),
463                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
464                                        template: liverSamplingEventTemplate)
465                                .setFieldValue('Sample weight',5F)
466                                .with { if (!validate()) { errors.each { println it} } else save()}
467
468                                def evS4 = new SamplingEvent(
469                                        startTime: Date.parse('yyyy-MM-dd','2008-01-14'),
470                                        endTime: Date.parse('yyyy-MM-dd','2008-01-14'),
471                                        template: liverSamplingEventTemplate)
472                                .setFieldValue('Sample weight',5F)
473                                .with { if (!validate()) { errors.each { println it} } else save()}
474
475                                // Add events to study
476                                mouseStudy
477                                .addToEvents(evLF)
478                                .addToEvents(evHF)
479                                .addToEvents(evBV)
480                                .addToEvents(evBL)
481                                .addToEvents(evLF4)
482                                .addToEvents(evHF4)
483                                .addToEvents(evBV4)
484                                .addToEvents(evBL4)
485                                .addToSamplingEvents(evS)
486                                .addToSamplingEvents(evS4)
487                                .save()
488
489                                def LFBV1 = new EventGroup(name:"10% fat + vehicle for 1 week")
490                                .addToEvents(evLF)
491                                .addToEvents(evBV)
492                                .addToEvents(evS)
493                                .with { if (!validate()) { errors.each { println it} } else save()}
494
495                                def LFBL1 = new EventGroup(name:"10% fat + leptin for 1 week")
496                                .addToEvents(evLF)
497                                .addToEvents(evBL)
498                                .addToEvents(evS)
499                                .with { if (!validate()) { errors.each { println it} } else save()}
500
501                                def HFBV1 = new EventGroup(name:"45% fat + vehicle for 1 week")
502                                .addToEvents(evHF)
503                                .addToEvents(evBV)
504                                .addToEvents(evS)
505                                .with { if (!validate()) { errors.each { println it} } else save()}
506
507                                def HFBL1 = new EventGroup(name:"45% fat + leptin for 1 week")
508                                .addToEvents(evHF)
509                                .addToEvents(evBL)
510                                .addToEvents(evS)
511                                .with { if (!validate()) { errors.each { println it} } else save()}
512
513                                def LFBV4 = new EventGroup(name:"10% fat + vehicle for 4 weeks")
514                                .addToEvents(evLF4)
515                                .addToEvents(evBV4)
516                                .addToEvents(evS4)
517                                .with { if (!validate()) { errors.each { println it} } else save()}
518
519                                def LFBL4 = new EventGroup(name:"10% fat + leptin for 4 weeks")
520                                .addToEvents(evLF4)
521                                .addToEvents(evBL4)
522                                .addToEvents(evS4)
523                                .with { if (!validate()) { errors.each { println it} } else save()}
524
525                                def HFBV4 = new EventGroup(name:"45% fat + vehicle for 4 weeks")
526                                .addToEvents(evHF4)
527                                .addToEvents(evBV4)
528                                .addToEvents(evS4)
529                                .with { if (!validate()) { errors.each { println it} } else save()}
530
531                                def HFBL4 = new EventGroup(name:"45% fat + leptin for 4 weeks")
532                                .addToEvents(evHF4)
533                                .addToEvents(evBL4)
534                                .addToEvents(evS4)
535                                .with { if (!validate()) { errors.each { println it} } else save()}
536
537                                // Add subjects and samples and compose EventGroups
538                                def x=1
539                                20.times {
540                                        def currentSubject = new Subject(
541                                                name: "A" + x++,
542                                                species: mouseTerm,
543                                                template: mouseTemplate,
544                                        )
545                                        .setFieldValue("Gender", "Male")
546                                        .setFieldValue("Genotype", c57bl6Term)
547                                        .setFieldValue("Age (weeks)", 17)
548                                        .setFieldValue("Cage", "" + (int)(x/2))
549                                        .with { if (!validate()) { errors.each { println it} } else save(flush:true)}
550
551                                        mouseStudy.addToSubjects(currentSubject)
552                                        .with { if (!validate()) { errors.each { println it} } else save()}
553
554                                        // Add subject to appropriate EventGroup
555                                        if (x > 70) { HFBL4.addToSubjects(currentSubject).save() }
556                                        else if (x > 60) { HFBV4.addToSubjects(currentSubject).save() }
557                                        else if (x > 50) { LFBL4.addToSubjects(currentSubject).save() }
558                                        else if (x > 40) { LFBV4.addToSubjects(currentSubject).save() }
559                                        else if (x > 30) { HFBL1.addToSubjects(currentSubject).save() }
560                                        else if (x > 20) { HFBV1.addToSubjects(currentSubject).save() }
561                                        else if (x > 10) { LFBL1.addToSubjects(currentSubject).save() }
562                                        else             { LFBV1.addToSubjects(currentSubject).save() }
563
564                                }
565
566                                // Add EventGroups to study
567                                mouseStudy
568                                .addToEventGroups(LFBV1)
569                                .addToEventGroups(LFBL1)
570                                .addToEventGroups(HFBV1)
571                                .addToEventGroups(HFBL1)
572                                .addToEventGroups(LFBV4)
573                                .addToEventGroups(LFBL4)
574                                .addToEventGroups(HFBV4)
575                                .addToEventGroups(HFBL4)
576
577                                // Add persons and publications to study
578                                def studyperson1 = new StudyPerson( person: person1, role: role1 ).save();
579                                def studyperson2 = new StudyPerson( person: person2, role: role2 ).save();
580
581                                mouseStudy
582                                .addToPersons( studyperson1 )
583                                .addToPersons( studyperson2 )
584                                .addToPublications( publication1 )
585                                .addToPublications( publication2 )
586                                .save()
587
588                                println ".adding NuGO PPSH example study..."
589
590                                def humanStudy = new Study(
591                                        template: studyTemplate,
592                                        title:"NuGO PPS human study",
593                                        code:"PPSH",
594                                        researchQuestion:"How much are fasting plasma and urine metabolite levels affected by prolonged fasting ?",
595                                        description:"Human study",
596                                        ecCode:"unknown",
597                                        startDate: Date.parse('yyyy-MM-dd','2008-01-14'))
598                                .setFieldValue( 'Description', "Human study performed at RRI; centres involved: RRI, IFR, TUM, Maastricht U." )
599                                .with { if (!validate()) { errors.each { println it} } else save()}
600
601                                def rootGroup = new EventGroup(name: 'Root group');
602
603                                def fastingEvent = new Event(
604                                        startTime: Date.parse('yyyy-MM-dd HH:mm','2008-01-14 22:00'),
605                                        endTime: Date.parse('yyyy-MM-dd HH:mm','2008-01-15 08:00'),
606                                        template: fastingTreatment)
607                                .setFieldValue('Fasting period','8h');
608
609
610                                def bloodSamplingEvent = new SamplingEvent(
611                                        startTime: Date.parse('yyyy-MM-dd HH:mm','2008-01-15 08:00'),
612                                        endTime: Date.parse('yyyy-MM-dd HH:mm','2008-01-15 08:00'),
613                                        template: bloodSamplingEventTemplate)
614                                .setFieldValue('Sample volume',4.5F);
615
616                                rootGroup.addToEvents fastingEvent
617                                rootGroup.addToEvents bloodSamplingEvent
618                                rootGroup.save()
619
620                                def y = 1
621                                11.times {
622                                        def currentSubject = new Subject(
623                                              name: "" + y++,
624                                              species: humanTerm,
625                                              template: humanTemplate)
626                                        .setFieldValue("Gender", (Math.random() > 0.5) ? "Male" : "Female")
627                                        .setFieldValue("DOB", new java.text.SimpleDateFormat("dd-mm-yy").parse("01-02-19" + (10 + (int) (Math.random() * 80))))
628                                        .setFieldValue("Age (years)", 30)
629                                        .setFieldValue("Height", Math.random() * 2F)
630                                        .setFieldValue("Weight (kg)", Math.random() * 150F)
631                                        .setFieldValue("BMI", 20 + Math.random() * 10F)
632                                        .with { if (!validate()) { errors.each { println it} } else save()}
633
634                                        rootGroup.addToSubjects currentSubject
635                                        rootGroup.save()
636
637                                        def currentSample = new Sample(
638                                              name: currentSubject.name + '_B',
639                                              material: bloodTerm,
640                                              parentSubject: currentSubject,
641                                              parentEvent: bloodSamplingEvent);
642
643                                        humanStudy.addToSubjects(currentSubject).addToSamples(currentSample).with { if (!validate()) { errors.each { println it} } else save()}
644                                }
645
646                                humanStudy.addToEvents(fastingEvent)
647                                humanStudy.addToSamplingEvents(bloodSamplingEvent)
648                                humanStudy.addToEventGroups rootGroup
649
650
651                                // Add persons to study
652                                def studyperson3 = new StudyPerson( person: person1, role: role2 ).save();
653
654                                humanStudy
655                                .addToPersons( studyperson3 )
656                                .addToPublications( publication2 )
657                                .save()
658
659                                /*
660                                // Add clinical data
661
662                                def lipidAssay = new dbnp.clinicaldata.ClinicalAssay(
663                                        name: 'Lipid profile',
664                                        approved: true
665                                ).with { if (!validate()) { errors.each { println it} } else save()}
666
667                                def ldlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement(
668                                        name: 'LDL',
669                                        unit: 'mg/dL',
670                                        type: dbnp.data.FeatureType.QUANTITATIVE,
671                                        referenceValues: '100 mg/dL',
672                                        detectableLimit: 250,
673                                        isDrug: false, isIntake: true, inSerum: true
674                                ).with { if (!validate()) { errors.each { println it} } else save()}
675
676                                def hdlMeasurement = new dbnp.clinicaldata.ClinicalMeasurement(
677                                        name: 'HDL',
678                                        unit: 'mg/dL',
679                                        type: dbnp.data.FeatureType.QUANTITATIVE,
680                                        referenceValues: '50 mg/dL',
681                                        detectableLimit: 100,
682                                        isDrug: false, isIntake: true, inSerum: true
683                                ).with { if (!validate()) { errors.each { println it} } else save()}
684
685                                lipidAssay.addToMeasurements ldlMeasurement
686                                lipidAssay.addToMeasurements hdlMeasurement
687
688                                def lipidAssayInstance = new dbnp.clinicaldata.ClinicalAssayInstance(
689                                        assay: lipidAssay
690                                ).with { if (!validate()) { errors.each { println it} } else save()}
691
692                                humanStudy.samples*.each {
693                                        new dbnp.clinicaldata.ClinicalFloatData(
694                                                assay: lipidAssayInstance,
695                                                measurement: ldlMeasurement,
696                                                sample: it.name,
697                                                value: Math.round(Math.random()*ldlMeasurement.detectableLimit)
698                                        ).with { if (!validate()) { errors.each { println it} } else save()}
699
700                                        new dbnp.clinicaldata.ClinicalFloatData(
701                                                assay: lipidAssayInstance,
702                                                measurement: hdlMeasurement,
703                                                sample: it.name,
704                                                value: Math.round(Math.random()*hdlMeasurement.detectableLimit)
705                                        ).with { if (!validate()) { errors.each { println it} } else save()}
706                                }
707                                */
708                                // Add assay to study capture module
709
710                                def clinicalModule = new AssayModule(
711                                        name: 'Clinical data',
712                                        type: AssayType.CLINICAL_DATA,
713                                        platform: 'clinical measurements',
714                                        url: 'http://localhost:8080/gscf'
715                                ).with { if (!validate()) { errors.each { println it} } else save()}
716
717                                def lipidAssayRef = new Assay(
718                                        name: 'Lipid profiling',
719                                        module: clinicalModule,
720                                        externalAssayId: 0
721                                ).with { if (!validate()) { errors.each { println it} } else save()}
722
723                                humanStudy.samples*.each {
724                                        lipidAssayRef.addToSamples(it)
725                                }
726                                lipidAssayRef.save()
727
728                                humanStudy.addToAssays(lipidAssayRef);
729                                humanStudy.save()
730
731                                mouseStudy.addToAssays(lipidAssayRef);
732                                mouseStudy.save()
733
734                        }
735                }
736        }
737
738        def destroy = {
739        }
740} 
Note: See TracBrowser for help on using the repository browser.