00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031 #include "SundanceExprFieldWrapper.hpp"
00032 #include "SundanceOut.hpp"
00033 #include "PlayaTabs.hpp"
00034 #include "SundanceDiscreteFunction.hpp"
00035 #include "SundanceLagrange.hpp"
00036 #include "SundanceEdgeLocalizedBasis.hpp"
00037 #include "SundanceDiscreteFuncElement.hpp"
00038 #include "SundanceHNDoFMapBase.hpp"
00039
00040 using namespace Sundance;
00041 using namespace Teuchos;
00042 using namespace Playa;
00043
00044
00045 ExprFieldWrapper::ExprFieldWrapper(const Expr& expr)
00046 : expr_(expr),
00047 df_(),
00048 discreteSpace_(),
00049
00050 indices_(),
00051 Expr_size_(1),
00052 isPointData_(true)
00053 {
00054 int index = 0;
00055 Expr_size_ = expr.size();
00056
00057 for(index = 0 ; index < Expr_size_ ; index++)
00058 {
00059 const DiscreteFunction* df
00060 = dynamic_cast<const DiscreteFunction*>(expr[index].ptr().get());
00061 const DiscreteFuncElement* dfe
00062 = dynamic_cast<const DiscreteFuncElement*>(expr[index].ptr().get());
00063 if (df != 0)
00064 {
00065 discreteSpace_ = df->discreteSpace();
00066
00067 indices_.append(tuple(0));
00068 BasisFamily basis = discreteSpace_.basis()[0];
00069 const Lagrange* lagr = dynamic_cast<const Lagrange*>(basis.ptr().get());
00070 if (lagr != 0 && lagr->order()==0) isPointData_ = false;
00071 const EdgeLocalizedBasis* elb = dynamic_cast<const EdgeLocalizedBasis*>(basis.ptr().get());
00072 if (elb!=0) isPointData_ = false;
00073 df_ = df->data();
00074 }
00075 else if (dfe != 0)
00076 {
00077 const DiscreteFunctionData* f = DiscreteFunctionData::getData(dfe);
00078
00079 TEUCHOS_TEST_FOR_EXCEPTION(f == 0, std::runtime_error,
00080 "ExprFieldWrapper ctor argument "
00081 << expr << " is not a discrete function");
00082 discreteSpace_ = f->discreteSpace();
00083
00084 indices_.append(tuple(dfe->myIndex()));
00085 BasisFamily basis = discreteSpace_.basis()[indices_[index][0]];
00086 const Lagrange* lagr = dynamic_cast<const Lagrange*>(basis.ptr().get());
00087 if (lagr != 0 && lagr->order()==0) isPointData_ = false;
00088 const EdgeLocalizedBasis* elb = dynamic_cast<const EdgeLocalizedBasis*>(basis.ptr().get());
00089 if (elb!=0) isPointData_ = false;
00090
00091 df_ = f;
00092
00093 }
00094 else
00095 {
00096 TEUCHOS_TEST_FOR_EXCEPTION(df == 0 && dfe == 0, std::runtime_error,
00097 "ExprFieldWrapper ctor argument is not a discrete "
00098 "function");
00099 }
00100 }
00101 }
00102
00103
00104 double ExprFieldWrapper::getData(int cellDim, int cellID, int elem) const
00105 {
00106 Array<int> dofs;
00107
00108 discreteSpace_.map()->getDOFsForCell(cellDim, cellID, indices_[elem][0] , dofs);
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120 if ( dofs[0] < 0)
00121 {
00122 const HNDoFMapBase* HNMap
00123 = dynamic_cast<const HNDoFMapBase*>((discreteSpace_.map()).get());
00124 if (HNMap != 0 ){
00125 Array<double> coefs;
00126 double sum = 0.0;
00127 HNMap->getDOFsForHNCell( cellDim, cellID, indices_[elem][0] , dofs , coefs );
00128 for (int jj = 0 ; jj < dofs.size() ; jj++)
00129 {
00130 sum += coefs[jj] * df_->ghostView()->getElement(dofs[jj]);
00131 }
00132
00133 return sum;
00134
00135 }
00136 else
00137 {
00138 return 1.0;
00139 }
00140 }
00141 else
00142 {
00143 return df_->ghostView()->getElement(dofs[0]);
00144 }
00145 }
00146
00147
00148 bool ExprFieldWrapper::isDefined(int cellDim, int cellID, int elem) const
00149 {
00150
00151 RCP<const Set<int> > allowedFuncs
00152 = discreteSpace_.map()->allowedFuncsOnCellBatch(cellDim, tuple(cellID));
00153
00154
00155
00156 return allowedFuncs->contains(indices_[elem][0]);
00157 }