/[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 150 by jgs, Thu Sep 15 03:44:45 2005 UTC revision 151 by jgs, Thu Sep 22 01:55:00 2005 UTC
# Line 267  Bruce::checkParameters() Line 267  Bruce::checkParameters()
267    return true;    return true;
268  }  }
269    
 std::string  
 Bruce::getDescription() const  
 {  
   return "Bruce";  
 }  
   
270  bool  bool
271  Bruce::isValidFunctionSpaceType(int functionSpaceCode) const  Bruce::isValidFunctionSpaceType(int functionSpaceCode) const
272  {  {
# Line 295  Bruce::functionSpaceTypeAsString(int fun Line 289  Bruce::functionSpaceTypeAsString(int fun
289    }    }
290  }  }
291    
 int  
 Bruce::getContinuousFunctionCode() const  
 {  
   return ContinuousFunction;  
 }  
   
 int  
 Bruce::getFunctionCode() const  
 {  
   return Function;  
 }  
   
 int  
 Bruce::getDim() const  
 {  
   return m_origin.size();  
 }  
   
292  pair<int,int>  pair<int,int>
293  Bruce::getDataShape(int functionSpaceCode) const  Bruce::getDataShape(int functionSpaceCode) const
294  {  {
# Line 420  Bruce::setToX(escript::Data& out) const Line 396  Bruce::setToX(escript::Data& out) const
396    // shape needed to store the coordinates of each data-point in this    // shape needed to store the coordinates of each data-point in this
397    // Bruce domain    // Bruce domain
398    std::vector<int> dataShape = out.getDataPointShape();    std::vector<int> dataShape = out.getDataPointShape();
399    if (dataShape.size()!=1 || dataShape[0]!=dim) {    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;      stringstream temp;
405      temp << "Error - Incompatible shape Data object supplied to Bruce::setToX";      temp << "Error - Incompatible shape Data object supplied to Bruce::setToX";
406      throw BruceException(temp.str());      throw BruceException(temp.str());
# Line 438  Bruce::setToX(escript::Data& out) const Line 418  Bruce::setToX(escript::Data& out) const
418    
419        int sampleNo=0;        int sampleNo=0;
420        DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);        DataAbstract::ValueType::value_type* sampleData = out.getSampleData(sampleNo);
       //sampleData[0] = m_origin[0];  
421        sampleNo++;        sampleNo++;
422        if (sampleNo!=numSamples) {        if (sampleNo!=numSamples) {
423          stringstream temp;          stringstream temp;
# Line 512  Bruce::setToX(escript::Data& out) const Line 491  Bruce::setToX(escript::Data& out) const
491      // calculate the spatial coordinates of data-points      // calculate the spatial coordinates of data-points
492      // located on the cell centres of this Bruce domain      // located on the cell centres of this Bruce domain
493    
494      for (int i=0; i<numSamples; i++) {      if (dim==0) {
495        DataAbstract::ValueType::value_type* sampleData = out.getSampleData(i);  
496        for (int j=0; j<dim; j++) {        // Bruce domains in 0d space
497          //cout << "====> " << sampleData[j] << endl;  
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 {    } else {
# Line 539  void Line 633  void
633  Bruce::setToSize(escript::Data& out) const  Bruce::setToSize(escript::Data& out) const
634  {  {
635    
636      //
637      // determine functionSpace type expected by supplied Data object
638    int functionSpaceCode = out.getFunctionSpace().getTypeCode();    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);    std::pair<int,int> domainShape = getDataShape(functionSpaceCode);
644    if(domainShape.first!=out.getNumDataPointsPerSample() ||    if(domainShape.first!=out.getNumDataPointsPerSample() ||
645       domainShape.second!=out.getNumSamples()) {       domainShape.second!=out.getNumSamples()) {
646      stringstream temp;      stringstream temp;
647      temp << "Error - Incompatible Data object supplied to Bruce::setToX";      temp << "Error - Incompatible number of data-points Data object supplied to Bruce::setToSize";
648      throw BruceException(temp.str());      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();    std::vector<int> dataShape = out.getDataPointShape();
658    if (dataShape.size()!=0) {    if (dataShape.size()!=1 || dataShape[0]!=1) {
659      stringstream temp;      stringstream temp;
660      temp << "Error - Incompatible Data object supplied to Bruce::setToSize";      temp << "Error - Incompatible shape Data object supplied to Bruce::setToSize";
661      throw BruceException(temp.str());      throw BruceException(temp.str());
662    }    }
663    
664    int numSamples = domainShape.second;    double dp_size;
665    
666    if (functionSpaceCode==ContinuousFunction) {    if (functionSpaceCode==ContinuousFunction) {
667    
668      cout << "ContinuousFunction" << endl;      //
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    
     for (int i=0; i<numSamples; i++) {  
       DataAbstract::ValueType::value_type* sampleData = out.getSampleData(i);  
       //cout << "====> " << sampleData[0] << endl;  
753      }      }
754    
755    } else if (functionSpaceCode==Function) {    } else if (functionSpaceCode==Function) {
756    
757      cout << "Function" << endl;      //
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    
     for (int i=0; i<numSamples; i++) {  
       DataAbstract::ValueType::value_type* sampleData = out.getSampleData(i);  
       //cout << "====> " << sampleData[0] << endl;  
882      }      }
883    
884    } else {    } else {
# Line 612  Bruce::operator!=(const AbstractDomain& Line 917  Bruce::operator!=(const AbstractDomain&
917  }  }
918    
919  bool  bool
920  Bruce::isZero(DimVec vec) const  Bruce::isZero(DimVec vec)
921  {  {
922    for (int i=0; i<vec.size(); i++) {    for (int i=0; i<vec.size(); i++) {
923      if (vec[i] != 0) {      if (vec[i] != 0) {

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

  ViewVC Help
Powered by ViewVC 1.1.26