source: XIOS/trunk/src/parse_expr/expr_node.hpp @ 501

Last change on this file since 501 was 501, checked in by ymipsl, 10 years ago

Add licence copyright to all file ond directory src using the command :
svn propset -R copyright -F header_licence src

XIOS is now officialy under CeCILL licence

YM
  • Property copyright set to
    Software name : XIOS (Xml I/O Server)
    http://forge.ipsl.jussieu.fr/ioserver
    Creation date : January 2009
    Licence : CeCCIL version2
    see license file in root directory : Licence_CeCILL_V2-en.txt
    or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
    Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement)
    CNRS/IPSL (Institut Pierre Simon Laplace)
    Project Manager : Yann Meurdesoif
    yann.meurdesoif@cea.fr
File size: 13.9 KB
Line 
1#ifndef __XIOS_EXPR_NODE_HPP__
2#define __XIOS_EXPR_NODE_HPP__
3
4#include "variable.hpp"
5#include "simple_node_expr.hpp"
6#include "operator_expr.hpp"
7#include "lex_parser.hpp"
8
9namespace xios
10{
11  class CField ;
12///////////////////////////////////////
13//         class CNodeExpr           //
14///////////////////////////////////////
15 
16  class CNodeExpr 
17  {
18    public:
19    CNodeExpr(void) : reduced(false) {};
20   
21    bool reduced ;
22    bool isReduced(void) { return reduced ; } 
23    virtual ~CNodeExpr() {}
24  } ;
25
26////////////////////////////////////////////////////////////////////////
27
28///////////////////////////////////////
29//         class CScalarNode           //
30///////////////////////////////////////
31
32  class CScalarNode : public CNodeExpr
33  {
34    public:
35    CScalarNode(void) : CNodeExpr() {}
36    static CScalarNode* newNode(CSimpleNodeExpr* simpleNode) ;
37    virtual void reduce(void)=0 ; 
38     
39    double val ;
40    virtual ~CScalarNode() {}
41  } ;
42
43////////////////////////////////////////////////////////////////////////
44
45///////////////////////////////////////
46//      class CScalarDouble          //
47///////////////////////////////////////
48
49  class CScalarDouble : public CScalarNode
50  {
51    public :
52   
53    CScalarDouble(CSimpleNodeExpr* simpleNode) : CScalarNode()
54    {
55      strVal=simpleNode->id ;
56    }
57   
58    virtual void reduce(void)
59    {
60      if (!reduced)
61      {
62        CType<double> tval ;
63        tval.fromString(strVal) ;
64        val=tval ;
65        reduced=true ;
66      }
67    }
68   
69    virtual ~CScalarDouble() {}
70    string strVal ;
71  } ;
72
73
74////////////////////////////////////////////////////////////////////////
75
76///////////////////////////////////////
77//       class CScalarVariable       //
78///////////////////////////////////////
79
80
81
82  class CScalarVariable : public CScalarNode
83  {
84    public :
85    CScalarVariable(CSimpleNodeExpr* simpleNode) : CScalarNode()
86    {
87      varId=simpleNode->id ;
88    }
89   
90    void reduce(void)
91    {
92      if (!reduced)
93      {
94        if (CVariable::has(varId)) 
95        {
96          val=CVariable::get(varId)->getData<double>() ;
97          reduced=true ;
98        }
99        else ERROR("void CScalarVariable::reduce(void)",<<" Variable "<<varId<<" does not exist")
100      }
101    }
102    virtual ~CScalarVariable() {}
103    string varId ;
104  } ;
105
106////////////////////////////////////////////////////////////////////////
107
108///////////////////////////////////////
109//      class COperatorScalarNode    //
110///////////////////////////////////////
111
112
113  class COperatorScalarNode : public CScalarNode
114  {
115    public :
116    COperatorScalarNode(CSimpleNodeExpr* simpleNode) : CScalarNode()
117    {
118      opId=simpleNode->id ;
119      child=newNode(simpleNode->children[0]) ;
120    }
121   
122    void reduce(void)
123    {
124      child->reduce() ;
125      op=operatorExpr.getOpScalar(opId) ;
126      if (child->isReduced())
127      {
128       val=op(child->val) ;
129       reduced=true ;
130      }
131    }
132       
133    virtual ~COperatorScalarNode() { delete child; }
134   
135    CScalarNode* child ;
136    string opId ;
137    double (*op)(double) ;
138  } ;
139
140////////////////////////////////////////////////////////////////////////
141
142
143/////////////////////////////////////////////
144//   class COperatorScalarScalarNode       //
145/////////////////////////////////////////////
146
147  class COperatorScalarScalarNode : public CScalarNode
148  {
149    public : 
150    COperatorScalarScalarNode(CSimpleNodeExpr* simpleNode) : CScalarNode()
151    {
152      opId=simpleNode->id ;
153      child1=newNode(simpleNode->children[0]) ;
154      child2=newNode(simpleNode->children[1]) ;
155    }
156   
157    void reduce(void)
158    {
159      child1->reduce() ;
160      child2->reduce() ;
161      op=operatorExpr.getOpScalarScalar(opId) ;
162      if (child1->isReduced() && child2->isReduced())
163      {
164        op=operatorExpr.getOpScalarScalar(opId) ;
165        val=op(child1->val,child2->val) ;
166        reduced=true ;
167      }
168    }
169   
170    virtual ~COperatorScalarScalarNode()
171    {
172      delete child1 ;
173      delete child2 ;
174    }
175   
176    CScalarNode* child1 ;
177    CScalarNode* child2 ;
178    double (*op)(double,double) ;
179    string opId ;
180  } ;
181
182 
183////////////////////////////////////////////////////////////////////////
184
185///////////////////////////////////////
186//         class CFieldNode          //
187///////////////////////////////////////
188
189
190  class CFieldNode : public CNodeExpr
191  {
192    public:
193    CFieldNode(void) : CNodeExpr() {}
194    static CFieldNode* newNode(CSimpleNodeExpr* simpleNode) ;
195    virtual void reduce(CField* thisField, map<string,CField*>& associatedInstantField, map<string,CField*>& associatedAverageField) =0 ; 
196    virtual CArray<double,1> compute(void)=0 ;
197    virtual void getFieldIds(set<string>& fieldIds)=0 ;
198    virtual void getInstantFieldIds(set<string>& fieldIds)=0 ;
199    virtual void getAverageFieldIds(set<string>& fieldIds)=0 ;
200    virtual void getFields(set<CField*>& fields)=0 ;
201    virtual void getInstantFields(set<CField*>& fields)=0 ;
202    virtual void getAverageFields(set<CField*>& fields)=0 ;
203     
204    virtual ~CFieldNode() {}
205  } ;
206
207
208////////////////////////////////////////////////////////////////////////
209
210///////////////////////////////////////
211//       class CInstantFieldNode     //
212/////////////////////////////////////// 
213
214  class CInstantFieldNode : public CFieldNode
215  {
216    public:
217    CInstantFieldNode(CSimpleNodeExpr* simpleNode) : CFieldNode(), fieldId(simpleNode->id) {}
218    virtual void reduce(CField* thisField, map<string,CField*>& associatedInstantField, map<string,CField*>& associatedAverageField) ; 
219    virtual CArray<double,1> compute(void) { return CArray<double,1>(*array);}
220    virtual ~CInstantFieldNode() { }
221    virtual void getFieldIds(set<string>& fieldIds) { fieldIds.insert(fieldId) ;}
222    virtual void getInstantFieldIds(set<string>& fieldIds) { fieldIds.insert(fieldId) ;}
223    virtual void getAverageFieldIds(set<string>& fieldIds) { }
224    virtual void getFields(set<CField*>& fields) { fields.insert(field) ;}
225    virtual void getInstantFields(set<CField*>& fields) { fields.insert(field) ;}
226    virtual void getAverageFields(set<CField*>& fields) { }
227       
228    string fieldId;
229    CField* field ;
230    CArray<double,1>* array ;
231  };
232
233
234
235////////////////////////////////////////////////////////////////////////
236
237///////////////////////////////////////
238//       class CAverageFieldNode     //
239///////////////////////////////////////
240
241
242  class CAverageFieldNode : public CFieldNode
243  {
244    public:
245   
246    CAverageFieldNode(CSimpleNodeExpr* simpleNode) : CFieldNode(), fieldId(simpleNode->id) {}
247   
248    virtual void reduce(CField* thisField, map<string,CField*>& associatedInstantField, map<string,CField*>& associatedAverageField) ; 
249    virtual CArray<double,1> compute(void) { return CArray<double,1>(*array); }
250    virtual void getFieldIds(set<string>& fieldIds) { fieldIds.insert(fieldId) ;}
251    virtual void getInstantFieldIds(set<string>& fieldIds) { }
252    virtual void getAverageFieldIds(set<string>& fieldIds) { fieldIds.insert(fieldId) ;}
253    virtual void getFields(set<CField*>& fields) { fields.insert(field) ;}
254    virtual void getInstantFields(set<CField*>& fields) { } 
255    virtual void getAverageFields(set<CField*>& fields) { fields.insert(field) ;}
256    virtual ~CAverageFieldNode() {}
257    string fieldId;
258    CField* field ;
259    CArray<double,1>* array ;
260  };
261
262
263////////////////////////////////////////////////////////////////////////
264
265///////////////////////////////////////
266//         class COperatorFieldNode  //
267///////////////////////////////////////
268 
269  class COperatorFieldNode : public CFieldNode
270  {
271    public:
272   
273    COperatorFieldNode(CSimpleNodeExpr* simpleNode) : CFieldNode(), opId(simpleNode->id)
274    {
275      child=newNode(simpleNode->children[0]) ;
276    }
277   
278    virtual void reduce(CField* thisField, map<string,CField*>& associatedInstantField, map<string,CField*>& associatedAverageField) 
279    {
280      child->reduce(thisField, associatedInstantField, associatedAverageField) ;
281      op=operatorExpr.getOpField(opId) ;
282      reduced=true ;
283    }
284   
285    virtual void getFieldIds(set<string>& fieldIds) {child-> getFieldIds(fieldIds);}
286    virtual void getInstantFieldIds(set<string>& fieldIds) {child->  getInstantFieldIds(fieldIds) ;}
287    virtual void getAverageFieldIds(set<string>& fieldIds) {child->  getAverageFieldIds(fieldIds) ;}
288    virtual void getFields(set<CField*>& fields) { child-> getFields(fields) ;}
289    virtual void getInstantFields(set<CField*>& fields) {child-> getInstantFields(fields) ; } 
290    virtual void getAverageFields(set<CField*>& fields) {child-> getAverageFields(fields) ; }   
291    virtual CArray<double,1> compute(void)
292    {
293      return op(child->compute()) ;
294    }
295    virtual ~COperatorFieldNode() { delete child; }
296     
297    CFieldNode* child ;
298    string opId ;
299    CArray<double,1> (*op)( const CArray<double,1>&) ;
300  };
301
302
303////////////////////////////////////////////////////////////////////////
304
305///////////////////////////////////////
306//     COperatorFieldFieldNode       //
307///////////////////////////////////////
308
309 
310  class COperatorFieldFieldNode : public CFieldNode
311  {
312    public:
313   
314    COperatorFieldFieldNode(CSimpleNodeExpr* simpleNode) : CFieldNode(),opId(simpleNode->id) 
315    {
316      child1=newNode(simpleNode->children[0]) ;
317      child2=newNode(simpleNode->children[1]) ;
318    }
319   
320    virtual void reduce(CField* thisField, map<string,CField*>& associatedInstantField, map<string,CField*>& associatedAverageField)
321    {
322      child1->reduce(thisField, associatedInstantField, associatedAverageField) ;
323      child2->reduce(thisField, associatedInstantField, associatedAverageField) ;
324      op=operatorExpr.getOpFieldField(opId) ;
325      reduced=true ;
326    }
327
328    virtual void getFieldIds(set<string>& fieldIds) {child1-> getFieldIds(fieldIds); child2-> getFieldIds(fieldIds);}
329    virtual void getInstantFieldIds(set<string>& fieldIds) {child1-> getInstantFieldIds(fieldIds); child2-> getInstantFieldIds(fieldIds);}
330    virtual void getAverageFieldIds(set<string>& fieldIds) {child1-> getAverageFieldIds(fieldIds); child2-> getAverageFieldIds(fieldIds);}
331    virtual void getFields(set<CField*>& fields) {child1-> getFields(fields); child2-> getFields(fields);}
332    virtual void getInstantFields(set<CField*>& fields) {child1-> getInstantFields(fields); child2-> getInstantFields(fields);}
333    virtual void getAverageFields(set<CField*>& fields) {child1-> getAverageFields(fields); child2-> getAverageFields(fields);}
334
335    virtual CArray<double,1> compute(void)
336    {
337      return op(child1->compute(),child2->compute()) ;
338    }
339   
340    virtual ~COperatorFieldFieldNode() { delete child1; delete child2 ; }
341
342    CFieldNode* child1 ;
343    CFieldNode* child2 ;
344    string opId ;
345    CArray<double,1> (*op)( const CArray<double,1>&,const CArray<double,1>&) ;   
346  };
347
348
349////////////////////////////////////////////////////////////////////////
350
351////////////////////////////////////////////
352//   class COperatorScalarFieldNode       //
353////////////////////////////////////////////
354 
355  class COperatorScalarFieldNode : public CFieldNode
356  {
357    public:
358   
359    COperatorScalarFieldNode(CSimpleNodeExpr* simpleNode) : CFieldNode(), opId(simpleNode->id)
360    {
361      child1=CScalarNode::newNode(simpleNode->children[0]) ;
362      child2=newNode(simpleNode->children[1]) ;
363    }
364   
365    virtual void reduce(CField* thisField, map<string,CField*>& associatedInstantField, map<string,CField*>& associatedAverageField)
366    {
367      child1->reduce() ;
368      child2->reduce(thisField, associatedInstantField, associatedAverageField) ;
369      op=operatorExpr.getOpScalarField(opId) ;
370      reduced=true ;
371    }
372   
373    virtual void getFieldIds(set<string>& fieldIds) {child2-> getFieldIds(fieldIds);}
374    virtual void getInstantFieldIds(set<string>& fieldIds) {child2-> getInstantFieldIds(fieldIds);}
375    virtual void getAverageFieldIds(set<string>& fieldIds) {child2-> getAverageFieldIds(fieldIds);}
376    virtual void getFields(set<CField*>& fields) {child2-> getFields(fields);}
377    virtual void getInstantFields(set<CField*>& fields) {child2-> getInstantFields(fields);}
378    virtual void getAverageFields(set<CField*>& fields) {child2-> getAverageFields(fields);}
379
380    virtual CArray<double,1> compute(void)
381    {
382      return op(child1->val,child2->compute()) ;
383    }   
384   
385    ~COperatorScalarFieldNode() { delete child1 ; delete child2 ; }
386   
387    CScalarNode* child1 ;
388    CFieldNode* child2 ;
389    string opId ;
390    CArray<double,1> (*op)(double,const CArray<double,1>&) ;       
391  };
392
393
394////////////////////////////////////////////////////////////////////////
395
396///////////////////////////////////////////
397//    class COperatorFieldScalarNode     //
398///////////////////////////////////////////
399 
400  class COperatorFieldScalarNode : public CFieldNode
401  {
402    public:
403   
404    COperatorFieldScalarNode(CSimpleNodeExpr* simpleNode) : CFieldNode(), opId(simpleNode->id)
405    {
406      child1=newNode(simpleNode->children[0]) ;
407      child2=CScalarNode::newNode(simpleNode->children[1]) ;
408    }
409   
410    virtual void reduce(CField* thisField, map<string,CField*>& associatedInstantField, map<string,CField*>& associatedAverageField)
411    {
412      child1->reduce(thisField, associatedInstantField, associatedAverageField) ;
413      child2->reduce() ;
414      op=operatorExpr.getOpFieldScalar(opId) ;
415      reduced=true ;
416    }
417   
418    virtual CArray<double,1> compute(void)
419    {
420      return op(child1->compute(),child2->val) ;
421    }
422   
423    virtual void getFieldIds(set<string>& fieldIds) {child1-> getFieldIds(fieldIds);}
424    virtual void getInstantFieldIds(set<string>& fieldIds) {child1-> getInstantFieldIds(fieldIds);}
425    virtual void getAverageFieldIds(set<string>& fieldIds) {child1-> getAverageFieldIds(fieldIds);}
426    virtual void getFields(set<CField*>& fields) {child1-> getFields(fields);}
427    virtual void getInstantFields(set<CField*>& fields) {child1-> getInstantFields(fields);}
428    virtual void getAverageFields(set<CField*>& fields) {child1-> getAverageFields(fields);}
429
430    ~COperatorFieldScalarNode() {delete child1, delete child2; }
431         
432    CFieldNode* child1 ;
433    CScalarNode* child2 ;
434    string opId ;
435    CArray<double,1> (*op)( const CArray<double,1>&, double) ;   
436  };
437 
438}
439
440#endif
Note: See TracBrowser for help on using the repository browser.