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

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

  ViewVC Help
Powered by ViewVC 1.1.26