/[escript]/trunk/bruce/src/Bruce/Bruce.cpp
ViewVC logotype

Diff of /trunk/bruce/src/Bruce/Bruce.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 149 by jgs, Thu Sep 1 03:31:39 2005 UTC revision 153 by jgs, Tue Oct 25 01:51:20 2005 UTC
# Line 14  Line 14 
14  */  */
15    
16  #include "bruce/Bruce/Bruce.h"  #include "bruce/Bruce/Bruce.h"
17    #include "bruce/Bruce/BruceException.h"
18    
19  using namespace std;  using namespace std;
20  using namespace escript;  using namespace escript;
21    
22  namespace bruce {  namespace bruce {
23    
24  const int Bruce::Nodes=0;  const int Bruce::ContinuousFunction=0;
25  const int Bruce::Elements=1;  const int Bruce::Function=1;
26    
27    Bruce::FunctionSpaceNamesMapType Bruce::m_functionSpaceTypeNames;
28    
29  Bruce::Bruce()  Bruce::Bruce()
30  {  {
31      setFunctionSpaceTypeNames();
32    }
33    
34    Bruce::Bruce(DimVec v0, DimVec v1, DimVec v2,
35                 int n0, int n1, int n2,
36                 DimVec origin):
37      m_v0(v0), m_v1(v1), m_v2(v2),
38      m_n0(n0), m_n1(n1), m_n2(n2),
39      m_origin(origin)
40    {
41      if (!checkParameters()) {
42        stringstream temp;
43        temp << "Error - Invalid parameters supplied to constructor.";
44        throw BruceException(temp.str());
45      }
46      setFunctionSpaceTypeNames();
47  }  }
48    
49  Bruce::Bruce(const Bruce& other)  Bruce::Bruce(const Bruce& other):
50      m_v0(other.m_v0), m_v1(other.m_v1), m_v2(other.m_v2),
51      m_n0(other.m_n0), m_n1(other.m_n1), m_n2(other.m_n2),
52      m_origin(other.m_origin)
53  {  {
54      setFunctionSpaceTypeNames();
55  }  }
56    
57  Bruce::~Bruce()  Bruce::~Bruce()
58  {  {
59      m_n0=-1;
60      m_n1=-1;
61      m_n2=-1;
62      m_origin.clear();
63      m_v0.clear();
64      m_v1.clear();
65      m_v2.clear();
66    }
67    
68    void
69    Bruce::setFunctionSpaceTypeNames()
70    {
71      m_functionSpaceTypeNames.insert
72        (FunctionSpaceNamesMapType::value_type(Function,"Bruce_Function"));
73      m_functionSpaceTypeNames.insert
74        (FunctionSpaceNamesMapType::value_type(ContinuousFunction,"Bruce_ContinuousFunction"));
75  }  }
76    
77  bool  bool
78  Bruce::isValidFunctionSpaceType(int functionSpaceType) const  Bruce::checkParameters()
79  {  {
80    return (true);    if (m_origin.size()>3) {
81        return false;
82      }
83    
84      if (m_n0<1) {
85        m_n0=1;
86      }
87      if (m_n1<1) {
88        m_n1=1;
89      }
90      if (m_n2<1) {
91        m_n2=1;
92      }
93    
94      // reorder vectors and point counts according to point counts
95    
96      //
97      // domains in 3d space
98      if (m_origin.size()==3) {
99    
100        if (m_v0.size()==0) {
101    
102          // 0d domain in 3d space
103          if ( (m_v1.size()!=0) || (m_v2.size()!=0) ) {
104            return false;
105          }
106    
107          m_v0.clear();
108          m_v0.push_back(0);
109          m_v0.push_back(0);
110          m_v0.push_back(0);
111          m_v1.clear();
112          m_v1.push_back(0);
113          m_v1.push_back(0);
114          m_v1.push_back(0);
115          m_v2.clear();
116          m_v2.push_back(0);
117          m_v2.push_back(0);
118          m_v2.push_back(0);
119    
120          m_n0=1;
121          m_n1=1;
122          m_n2=1;
123    
124        } else if (m_v1.size()==0) {
125    
126          // 1d domain in 3d space
127          if ( (m_v0.size()!=3) || (m_v2.size()!=0) ) {
128            return false;
129          }
130    
131          m_v1.clear();
132          m_v1.push_back(0);
133          m_v1.push_back(0);
134          m_v1.push_back(0);
135          m_v2.clear();
136          m_v2.push_back(0);
137          m_v2.push_back(0);
138          m_v2.push_back(0);
139    
140          m_n1=1;
141          m_n2=1;
142    
143        } else if (m_v2.size()==0) {
144    
145          // 2d domain in 3d space
146          if ( (m_v0.size()!=3) || (m_v1.size()!=3) ) {
147            return false;
148          }
149    
150          m_v2.clear();
151          m_v2.push_back(0);
152          m_v2.push_back(0);
153          m_v2.push_back(0);
154    
155          m_n2=1;
156    
157        } else {
158    
159          // 3d domain in 3d space
160          if ( (m_v0.size()!=3) || (m_v1.size()!=3) || (m_v2.size()!=3) ) {
161            return false;
162          }
163    
164        }
165    
166      }
167    
168      //
169      // domains in 2d space
170      if (m_origin.size()==2) {
171    
172        if (m_v0.size()==0) {
173    
174          // 0d domain in 2d space
175          if (m_v1.size()!=0) {
176            return false;
177          }
178    
179          m_v0.clear();
180          m_v0.push_back(0);
181          m_v0.push_back(0);
182          m_v1.clear();
183          m_v1.push_back(0);
184          m_v1.push_back(0);
185          m_v2.clear();
186    
187          m_n0=1;
188          m_n1=1;
189          m_n2=1;
190    
191        } else if (m_v1.size()==0) {
192    
193          // 1d domain in 2d space
194          if (m_v0.size()!=2) {
195            return false;
196          }
197    
198          m_v1.clear();
199          m_v1.push_back(0);
200          m_v1.push_back(0);
201          m_v2.clear();
202    
203          m_n1=1;
204          m_n2=1;
205    
206        } else {
207    
208          // 2d domain in 2d space
209          if ( (m_v0.size()!=2) || (m_v1.size()!=2) ) {
210            return false;
211          }
212    
213          m_v2.clear();
214    
215          m_n2=1;
216    
217        }
218    
219      }
220    
221      //
222      // domains in 1d space
223      if (m_origin.size()==1) {
224    
225        if (m_v0.size()==0) {
226    
227          // 0d domain in 1d space
228          m_v0.clear();
229          m_v0.push_back(0);
230          m_v1.clear();
231          m_v2.clear();
232    
233          m_n0=1;
234          m_n1=1;
235          m_n2=1;
236    
237        } else {
238    
239          // 1d domain in 1d space
240          if (m_v0.size()!=1)  {
241            return false;
242          }
243    
244          m_v1.clear();
245          m_v2.clear();
246    
247          m_n1=1;
248          m_n2=1;
249    
250        }
251    
252      }
253    
254      //
255      // domains in 0d space
256      if (m_origin.size()==0) {
257    
258        // point (0d) domain in 0d space
259        m_v0.clear();
260        m_v1.clear();
261        m_v2.clear();
262    
263        m_n0=1;
264        m_n1=1;
265        m_n2=1;
266    
267      }
268    
269      return true;
270  }  }
271    
272  int  bool
273  Bruce::getDim() const  Bruce::isValidFunctionSpaceType(int functionSpaceCode) const
274  {  {
275    return 0;    FunctionSpaceNamesMapType::iterator loc;
276      loc=m_functionSpaceTypeNames.find(functionSpaceCode);
277      return (loc!=m_functionSpaceTypeNames.end());
278    }
279    
280    std::string
281    Bruce::functionSpaceTypeAsString(int functionSpaceCode) const
282    {
283      FunctionSpaceNamesMapType::iterator loc;
284      loc=m_functionSpaceTypeNames.find(functionSpaceCode);
285      if (loc==m_functionSpaceTypeNames.end()) {
286        stringstream temp;
287        temp << "Error - Invalid function space type code.";
288        throw BruceException(temp.str());
289      } else {
290        return loc->second;
291      }
292  }  }
293    
294  pair<int,int>  pair<int,int>
295  Bruce::getDataShape(int functionSpaceCode) const  Bruce::getDataShape(int functionSpaceCode) const
296  {  {
297    int numDataPointsPerSample=0;    int numDataPointsPerSample=1;
298    int numSamples=0;    int numSamples;
299    
300      switch (functionSpaceCode) {
301    
302          //
303          // Continuous functions
304          case(ContinuousFunction):
305    
306              numSamples = m_n0 * m_n1 * m_n2;
307              break;
308    
309          //
310          // Functions
311          case(Function):
312    
313              // 0d domains
314              if (getDim()==0) {
315    
316                numSamples = 0;
317    
318              // 1d domains
319              } else if (getDim()==1) {
320    
321                if (isZero(m_v0)) {
322                  numSamples = 0;
323                } else {
324                  numSamples = m_n0-1;
325                }
326    
327              // 2d domains
328              } else if (getDim()==2) {
329    
330                if (isZero(m_v0)) {
331                  numSamples = 0;
332                } else if (isZero(m_v1)) {
333                  numSamples = m_n0-1;
334                } else {
335                  numSamples = (m_n0-1) * (m_n1-1);
336                }
337    
338              // 3d domains
339              } else {
340    
341                if (isZero(m_v0)) {
342                  numSamples = 0;
343                } else if (isZero(m_v1)) {
344                  numSamples = m_n0-1;
345                } else if (isZero(m_v2)) {
346                  numSamples = (m_n0-1) * (m_n1-1);
347                } else {
348                  numSamples = (m_n0-1) * (m_n1-1) * (m_n2-1);
349                }
350    
351              }
352    
353              break;
354    
355          default:
356              stringstream temp;
357              temp << "Error - Invalid function space type: "
358                   << functionSpaceCode << " for domain: " << getDescription();
359              throw BruceException(temp.str());
360              break;
361    
362      }
363    
364    return pair<int,int>(numDataPointsPerSample,numSamples);    return pair<int,int>(numDataPointsPerSample,numSamples);
365  }  }
366    
367    Data
368    Bruce::getX() const
369    {
370      FunctionSpace tempFunc = continuousFunction(asAbstractContinuousDomain());
371      return tempFunc.getX();
372    }
373    
374    void
375    Bruce::setToX(escript::Data& out) const
376    {
377    
378      //
379      // determine functionSpace type expected by supplied Data object
380      int functionSpaceCode = out.getFunctionSpace().getTypeCode();
381    
382      //
383      // ensure supplied Data object has a matching number of data-points
384      // for this Bruce domain object
385      std::pair<int,int> domainShape = getDataShape(functionSpaceCode);
386      if(domainShape.first!=out.getNumDataPointsPerSample() ||
387         domainShape.second!=out.getNumSamples()) {
388        stringstream temp;
389        temp << "Error - Incompatible number of data-points Data object supplied to Bruce::setToX";
390        throw BruceException(temp.str());
391      }
392    
393      int dim = getDim();
394      int numSamples = domainShape.second;
395    
396      //
397      // ensure shape of data-points in supplied Data object matches the
398      // shape needed to store the coordinates of each data-point in this
399      // Bruce domain
400      std::vector<int> dataShape = out.getDataPointShape();
401      if (dim>0 && (dataShape.size()!=1 || dataShape[0]!=dim)) {
402        stringstream temp;
403        temp << "Error - Incompatible shape Data object supplied to Bruce::setToX";
404        throw BruceException(temp.str());
405      } else if (dim==0 && dataShape.size()!=0) {
406        stringstream temp;
407        temp << "Error - Incompatible shape Data object supplied to Bruce::setToX";
408        throw BruceException(temp.str());
409      }
410    
411      if (functionSpaceCode==ContinuousFunction) {
412    
413        //
414        // calculate the spatial coordinates of data-points
415        // located on the nodes of this Bruce domain
416    
417        if (dim==0) {
418    
419          // Bruce domains in 0d space
420    
421          int sampleNo=0;
422          DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
423    
424        } else if (dim==1) {
425    
426          // Bruce domains in 1d space
427    
428          for (int i=0; i<m_n0; i++) {
429            int sampleNo=i;
430            DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
431            sampleData[0] = m_origin[0] + m_v0[0]*i;
432          }
433    
434        } else if (dim==2) {
435    
436          // Bruce domains in 2d space
437    
438          for (int i=0; i<m_n0; i++) {
439            for (int j=0; j<m_n1; j++) {
440              int sampleNo=(m_n1*i)+j;
441              DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
442              for (int d=0; d<dim; d++) {
443                sampleData[d] = m_origin[d] + m_v0[d]*i + m_v1[d]*j;
444              }
445            }
446          }
447    
448        } else if (dim==3) {
449    
450          // Bruce domains in 3d space
451    
452          for (int i=0; i<m_n0; i++) {
453            for (int j=0; j<m_n1; j++) {
454              for (int k=0; k<m_n2; k++) {
455                int sampleNo=(m_n1*m_n2*i)+(m_n2*j)+k;
456                DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
457                for (int d=0; d<dim; d++) {
458                  sampleData[d] = m_origin[d] + m_v0[d]*i + m_v1[d]*j + m_v2[d]*k;
459                }
460              }
461            }
462          }
463    
464        }
465    
466      } else if (functionSpaceCode==Function) {
467    
468        //
469        // calculate the spatial coordinates of data-points
470        // located on the cell centres of this Bruce domain
471    
472        if (dim==0) {
473    
474          // Bruce domains in 0d space
475    
476          stringstream temp;
477          temp << "Error - Invalid function space type: "
478               << functionSpaceCode << " for Bruce::setToX";
479          throw BruceException(temp.str());
480    
481        } else if (dim==1) {
482    
483          // Bruce domains in 1d space
484    
485          int n0max=m_n0-1;
486          if (isZero(m_v0)) {
487            stringstream temp;
488            temp << "Error - Invalid function space type: "
489                 << functionSpaceCode << " for Bruce::setToX";
490            throw BruceException(temp.str());
491          } else {
492            for (int i=0; i<n0max; i++) {
493              int sampleNo=i;
494              DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
495              sampleData[0] = m_origin[0] + m_v0[0]*(i + 0.5);
496            }
497          }
498    
499        } else if (dim==2) {
500    
501          // Bruce domains in 2d space
502    
503          int n0max=m_n0-1;
504          int n1max=m_n1-1;
505          if (isZero(m_v0)) {
506            stringstream temp;
507            temp << "Error - Invalid function space type: "
508                 << functionSpaceCode << " for Bruce::setToX";
509            throw BruceException(temp.str());
510          } else if (isZero(m_v1)) {
511            for (int i=0; i<n0max; i++) {
512              int sampleNo=i;
513              DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
514              for (int d=0; d<dim; d++) {
515                sampleData[d] = m_origin[d] + m_v0[d]*(i + 0.5);
516              }
517            }
518          } else {
519            for (int i=0; i<n0max; i++) {
520              for (int j=0; j<n1max; j++) {
521                int sampleNo=(n1max*i)+j;
522                DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
523                for (int d=0; d<dim; d++) {
524                  sampleData[d] = m_origin[d] + m_v0[d]*(i + 0.5) + m_v1[d]*(j + 0.5);
525                }
526              }
527            }
528          }
529    
530        } else if (dim==3) {
531    
532          // Bruce domains in 3d space
533    
534          int n0max=m_n0-1;
535          int n1max=m_n1-1;
536          int n2max=m_n2-1;
537          if (isZero(m_v0)) {
538            stringstream temp;
539            temp << "Error - Invalid function space type: "
540                 << functionSpaceCode << " for Bruce::setToX";
541            throw BruceException(temp.str());
542          } else if (isZero(m_v1)) {
543            for (int i=0; i<n0max; i++) {
544              int sampleNo=i;
545              DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
546              for (int d=0; d<dim; d++) {
547                sampleData[d] = m_origin[d] + m_v0[d]*(i + 0.5);
548              }
549            }
550          } else if (isZero(m_v2)) {
551            for (int i=0; i<n0max; i++) {
552              for (int j=0; j<n1max; j++) {
553                int sampleNo=(n1max*i)+j;
554                DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
555                for (int d=0; d<dim; d++) {
556                  sampleData[d] = m_origin[d] + m_v0[d]*(i + 0.5) + m_v1[d]*(j + 0.5);
557                }
558              }
559            }
560          } else {
561            for (int i=0; i<n0max; i++) {
562              for (int j=0; j<n1max; j++) {
563                for (int k=0; k<n2max; k++) {
564                  int sampleNo=(n1max*n2max*i)+(n2max*j)+k;
565                  DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
566                  for (int d=0; d<dim; d++) {
567                    sampleData[d] = m_origin[d] + m_v0[d]*(i + 0.5) + m_v1[d]*(j + 0.5) + m_v2[d]*(k + 0.5);
568                  }
569                }
570              }
571            }
572          }
573    
574        }
575    
576      } else {
577        stringstream temp;
578        temp << "Error - Invalid function space type: "
579             << functionSpaceCode << " for domain: " << getDescription();
580        throw BruceException(temp.str());
581      }
582    
583    }
584    
585    Data
586    Bruce::getSize() const
587    {
588      FunctionSpace tempFunc = function(asAbstractContinuousDomain());
589      return tempFunc.getSize();
590    }
591    
592    void
593    Bruce::setToSize(escript::Data& out) const
594    {
595    
596      //
597      // determine functionSpace type expected by supplied Data object
598      int functionSpaceCode = out.getFunctionSpace().getTypeCode();
599    
600      //
601      // ensure supplied Data object has a matching number of data-points
602      // for this Bruce domain object
603      std::pair<int,int> domainShape = getDataShape(functionSpaceCode);
604      if(domainShape.first!=out.getNumDataPointsPerSample() ||
605         domainShape.second!=out.getNumSamples()) {
606        stringstream temp;
607        temp << "Error - Incompatible number of data-points Data object supplied to Bruce::setToSize";
608        throw BruceException(temp.str());
609      }
610    
611      int dim = getDim();
612      int numSamples = domainShape.second;
613    
614      //
615      // ensure shape of data-points in supplied Data object matches the
616      // shape needed to store the size of each data-point in this Bruce domain
617      std::vector<int> dataShape = out.getDataPointShape();
618      // this check should be satisfied by Data objects passed to setToSize, but
619      // FunctionSpace::getSize() seems to create an object which is larger than
620      // this... either way, this method can deal with this
621    /*
622      if (dataShape.size()!=1 || dataShape[0]!=1) {
623        stringstream temp;
624        temp << "Error - Incompatible shape Data object supplied to Bruce::setToSize";
625        throw BruceException(temp.str());
626      }
627    */
628    
629      double dp_size;
630    
631      if (functionSpaceCode==ContinuousFunction) {
632    
633        //
634        // calculate the size of data-points
635        // located on the nodes of this Bruce domain
636    
637        if (dim==0) {
638    
639          // Bruce domains in 0d space
640    
641          dp_size = 0.0;
642    
643          int sampleNo=0;
644          DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
645          sampleData[0] = dp_size;
646    
647        } else if (dim==1) {
648    
649          // Bruce domains in 1d space
650    
651          dp_size = m_v0[0];
652    
653          for (int i=0; i<m_n0; i++) {
654            int sampleNo=i;
655            DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
656            sampleData[0] = dp_size;
657          }
658    
659        } else if (dim==2) {
660    
661          // Bruce domains in 2d space
662    
663          double x = m_v0[0] + m_v1[0];
664          double y = m_v0[1] + m_v1[1];
665          dp_size = sqrt(pow(x,2)+pow(y,2));
666    
667          for (int i=0; i<m_n0; i++) {
668            for (int j=0; j<m_n1; j++) {
669              int sampleNo=(m_n1*i)+j;
670              DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
671              sampleData[0] = dp_size;
672            }
673          }
674    
675        } else if (dim==3) {
676    
677          // Bruce domains in 3d space
678    
679          double x = m_v0[0] + m_v1[0] + m_v2[0];
680          double y = m_v0[1] + m_v1[1] + m_v2[1];
681          double z = m_v0[2] + m_v1[2] + m_v2[2];
682          dp_size = sqrt(pow(x,2)+pow(y,2)+pow(z,2));
683    
684          for (int i=0; i<m_n0; i++) {
685            for (int j=0; j<m_n1; j++) {
686              for (int k=0; k<m_n2; k++) {
687                int sampleNo=(m_n1*m_n2*i)+(m_n2*j)+k;
688                DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
689                sampleData[0] = dp_size;
690              }
691            }
692          }
693    
694        }
695    
696      } else if (functionSpaceCode==Function) {
697    
698        //
699        // calculate the sizes of data-points
700        // located on the cell centres of this Bruce domain
701    
702        if (dim==0) {
703    
704          // Bruce domains in 0d space
705    
706          stringstream temp;
707          temp << "Error - Invalid function space type: "
708               << functionSpaceCode << " for Bruce::setToSize";
709          throw BruceException(temp.str());
710    
711        } else if (dim==1) {
712    
713          // Bruce domains in 1d space
714    
715          dp_size = m_v0[0];
716    
717          int n0max=m_n0-1;
718          if (isZero(m_v0)) {
719            stringstream temp;
720            temp << "Error - Invalid function space type: "
721                 << functionSpaceCode << " for Bruce::setToSize";
722            throw BruceException(temp.str());
723          } else {
724            for (int i=0; i<n0max; i++) {
725              int sampleNo=i;
726              DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
727              sampleData[0] = dp_size;
728            }
729          }
730    
731        } else if (dim==2) {
732    
733          // Bruce domains in 2d space
734    
735          double x = m_v0[0] + m_v1[0];
736          double y = m_v0[1] + m_v1[1];
737          dp_size = sqrt(pow(x,2)+pow(y,2));
738    
739          int n0max=m_n0-1;
740          int n1max=m_n1-1;
741          if (isZero(m_v0)) {
742            stringstream temp;
743            temp << "Error - Invalid function space type: "
744                 << functionSpaceCode << " for Bruce::setToSize";
745            throw BruceException(temp.str());
746          } else if (isZero(m_v1)) {
747            for (int i=0; i<n0max; i++) {
748              int sampleNo=i;
749              DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
750              sampleData[0] = dp_size;
751            }
752          } else {
753            for (int i=0; i<n0max; i++) {
754              for (int j=0; j<n1max; j++) {
755                int sampleNo=(n1max*i)+j;
756                DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
757                sampleData[0] = dp_size;
758              }
759            }
760          }
761    
762        } else if (dim==3) {
763    
764          // Bruce domains in 3d space
765    
766          double x = m_v0[0] + m_v1[0] + m_v2[0];
767          double y = m_v0[1] + m_v1[1] + m_v2[1];
768          double z = m_v0[2] + m_v1[2] + m_v2[2];
769          dp_size = sqrt(pow(x,2)+pow(y,2)+pow(z,2));
770    
771          int n0max=m_n0-1;
772          int n1max=m_n1-1;
773          int n2max=m_n2-1;
774          if (isZero(m_v0)) {
775            stringstream temp;
776            temp << "Error - Invalid function space type: "
777                 << functionSpaceCode << " for Bruce::setToSize";
778            throw BruceException(temp.str());
779          } else if (isZero(m_v1)) {
780            for (int i=0; i<n0max; i++) {
781              int sampleNo=i;
782              DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
783              sampleData[0] = dp_size;
784            }
785          } else if (isZero(m_v2)) {
786            for (int i=0; i<n0max; i++) {
787              for (int j=0; j<n1max; j++) {
788                int sampleNo=(n1max*i)+j;
789                DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
790                sampleData[0] = dp_size;
791              }
792            }
793          } else {
794            for (int i=0; i<n0max; i++) {
795              for (int j=0; j<n1max; j++) {
796                for (int k=0; k<n2max; k++) {
797                  int sampleNo=(n2max*n1max*i)+(n1max*j)+k;
798                  DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
799                  sampleData[0] = dp_size;
800                }
801              }
802            }
803          }
804    
805        }
806    
807      } else {
808        stringstream temp;
809        temp << "Error - Invalid function space type: "
810             << functionSpaceCode << " for domain: " << getDescription();
811        throw BruceException(temp.str());
812      }
813    
814    }
815    
816  bool  bool
817  Bruce::operator==(const AbstractDomain& other) const  Bruce::operator==(const AbstractDomain& other) const
818  {  {
819    const Bruce* temp=dynamic_cast<const Bruce*>(&other);    const Bruce* temp=dynamic_cast<const Bruce*>(&other);
820    if (temp!=0) {    if (temp!=0) {
821      return (true);      if ((m_v0 != temp->m_v0) || (m_v1 != temp->m_v1) || (m_v2 != temp->m_v2)) {
822          return false;
823        }
824        if ((m_n0 != temp->m_n0) || (m_n1 != temp->m_n1) || (m_n2 != temp->m_n2)) {
825          return false;
826        }
827        if (m_origin != temp->m_origin) {
828          return false;
829        }
830        return true;
831    } else {    } else {
832      return false;      return false;
833    }    }
# Line 72  Bruce::operator!=(const AbstractDomain& Line 839  Bruce::operator!=(const AbstractDomain&
839    return !(operator==(other));    return !(operator==(other));
840  }  }
841    
842  Data  int
843  Bruce::getX() const  Bruce::getTagFromSampleNo(int functionSpaceCode, int sampleNo) const
844  {  {
845    return continuousFunction(asAbstractContinuousDomain()).getX();    return 0;
846  }  }
847    
848  Data  int
849  Bruce::getSize() const  Bruce::getReferenceNoFromSampleNo(int functionSpaceCode, int sampleNo) const
850  {  {
851    return function(asAbstractContinuousDomain()).getSize();    return 0;
852    }
853    
854    bool
855    Bruce::isZero(DimVec vec)
856    {
857      for (int i=0; i<vec.size(); i++) {
858        if (vec[i] != 0) {
859          return false;
860        }
861      }
862      return true;
863  }  }
864    
865  }  // end of namespace  }  // end of namespace

Legend:
Removed from v.149  
changed lines
  Added in v.153

  ViewVC Help
Powered by ViewVC 1.1.26