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

Last change on this file since 642 was 642, checked in by rlacroix, 9 years ago

Use the filter infrastructure to handle the expressions

Parse the expressions to get a new tree representation that can be converted to a filter graph based on new arithmetic filters.

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