Sundance 2.1

00001 /* @HEADER@ */
00002 // ************************************************************************
00003 // 
00004 //                              Sundance
00005 //                 Copyright (2005) Sandia Corporation
00006 // 
00007 // Copyright (year first published) Sandia Corporation.  Under the terms 
00008 // of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government 
00009 // retains certain rights in this software.
00010 // 
00011 // This library is free software; you can redistribute it and/or modify
00012 // it under the terms of the GNU Lesser General Public License as
00013 // published by the Free Software Foundation; either version 2.1 of the
00014 // License, or (at your option) any later version.
00015 //  
00016 // This library is distributed in the hope that it will be useful, but
00017 // WITHOUT ANY WARRANTY; without even the implied warranty of
00018 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00019 // Lesser General Public License for more details.
00020 //                                                                                 
00021 // You should have received a copy of the GNU Lesser General Public
00022 // License along with this library; if not, write to the Free Software
00023 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
00024 // USA                                                                                
00025 // Questions? Contact Kevin Long (krlong@sandia.gov), 
00026 // Sandia National Laboratories, Livermore, California, USA
00027 // 
00028 // ************************************************************************
00029 /* @HEADER@ */
00030 
00031 #include "SundanceEquationSet.hpp"
00032 #include "SundanceSymbPreprocessor.hpp"
00033 #include "SundanceFunctionSupportResolver.hpp"
00034 #include "SundanceUnknownFuncElement.hpp"
00035 #include "SundanceSpectralExpr.hpp"
00036 #include "SundanceUnknownParameterElement.hpp"
00037 #include "SundanceTestFuncElement.hpp"
00038 #include "PlayaExceptions.hpp"
00039 #include "SundanceIntegral.hpp"
00040 #include "SundanceListExpr.hpp"
00041 #include "SundanceEssentialBC.hpp"
00042 #include "SundanceSumOfIntegrals.hpp"
00043 #include "SundanceSumOfBCs.hpp"
00044 #include "SundanceOut.hpp"
00045 #include "PlayaTabs.hpp"
00046 
00047  
00048 
00049 
00050 
00051 using namespace Sundance;
00052 using namespace Teuchos;
00053 
00054 EquationSet::EquationSet(const Expr& eqns, 
00055   const Expr& bcs, 
00056   const Expr& params,
00057   const Expr& paramEvalPts,
00058   const Array<Expr>& fields,
00059   const Array<Expr>& fieldValues)
00060   : fsr_(),
00061     varUnkPairsOnRegions_(),
00062     bcVarUnkPairsOnRegions_(),
00063     regionQuadCombos_(),
00064     bcRegionQuadCombos_(),
00065     regionQuadComboExprs_(),
00066     bcRegionQuadComboExprs_(),
00067     regionQuadComboNonzeroDerivs_(),
00068     bcRegionQuadComboNonzeroDerivs_(),
00069     rqcToContext_(),
00070     bcRqcToContext_(),
00071     rqcToSkip_(),
00072     bcRqcToSkip_(),
00073     unkLinearizationPts_(),
00074     unkParamEvalPts_(),
00075     fixedParamEvalPts_(paramEvalPts),
00076     compTypes_(),
00077     isNonlinear_(false),
00078     isVariationalProblem_(true),
00079     isFunctionalCalculator_(true),
00080     isSensitivityProblem_(false)
00081 {
00082   Array<Expr> unks;
00083   Array<Expr> unkEvalPt;
00084   Array<Expr> vars;
00085   Array<Expr> varEvalPt;
00086   Expr unkParams;
00087 
00088   fsr_ = rcp(new FunctionSupportResolver(eqns, bcs, vars, unks, unkParams,
00089       params, fields, true));
00090   
00091   compTypes_.put(FunctionalOnly);
00092 
00093   rqcToContext_.put(FunctionalOnly, Map<RegionQuadCombo, EvalContext>());
00094   bcRqcToContext_.put(FunctionalOnly, Map<RegionQuadCombo, EvalContext>());
00095 
00096   regionQuadComboNonzeroDerivs_.put(FunctionalOnly,
00097     Map<RegionQuadCombo, DerivSet>());
00098   bcRegionQuadComboNonzeroDerivs_.put(FunctionalOnly,
00099     Map<RegionQuadCombo, DerivSet>());
00100 
00101   
00102 
00103   init(varEvalPt, unkEvalPt, unkParamEvalPts_, paramEvalPts, fieldValues);
00104 }
00105 
00106 EquationSet::EquationSet(const Expr& eqns, 
00107   const Expr& bcs,
00108   const Array<Expr>& vars, 
00109   const Array<Expr>& unks,
00110   const Array<Expr>& unkLinearizationPts,
00111   const Expr& unkParams,
00112   const Expr& unkParamEvalPts, 
00113   const Expr& params,
00114   const Expr& paramEvalPts,
00115   const Array<Expr>& fixedFields,
00116   const Array<Expr>& fixedFieldValues)
00117   : fsr_(),
00118     varUnkPairsOnRegions_(),
00119     bcVarUnkPairsOnRegions_(),
00120     regionQuadCombos_(),
00121     bcRegionQuadCombos_(),
00122     regionQuadComboExprs_(),
00123     bcRegionQuadComboExprs_(),
00124     regionQuadComboNonzeroDerivs_(),
00125     bcRegionQuadComboNonzeroDerivs_(),
00126     rqcToContext_(),
00127     bcRqcToContext_(),
00128     rqcToSkip_(),
00129     bcRqcToSkip_(),
00130     unkLinearizationPts_(flattenSpectral(unkLinearizationPts)),
00131     unkParamEvalPts_(unkParamEvalPts),
00132     fixedParamEvalPts_(paramEvalPts),
00133     compTypes_(),
00134     isNonlinear_(false),
00135     isVariationalProblem_(false),
00136     isFunctionalCalculator_(false),
00137     isSensitivityProblem_(unkParams.size() > 0)
00138 {
00139   compTypes_.put(MatrixAndVector);
00140   compTypes_.put(VectorOnly);
00141 
00142   fsr_ = rcp(new FunctionSupportResolver(eqns, bcs, vars, 
00143       unks, unkParams,
00144       params, fixedFields, false));
00145 
00146   rqcToContext_.put(MatrixAndVector, Map<RegionQuadCombo, EvalContext>());
00147   bcRqcToContext_.put(MatrixAndVector, Map<RegionQuadCombo, EvalContext>());
00148 
00149   rqcToContext_.put(VectorOnly, Map<RegionQuadCombo, EvalContext>());
00150   bcRqcToContext_.put(VectorOnly, Map<RegionQuadCombo, EvalContext>());
00151 
00152   regionQuadComboNonzeroDerivs_.put(MatrixAndVector, 
00153     Map<RegionQuadCombo, DerivSet>());
00154   bcRegionQuadComboNonzeroDerivs_.put(MatrixAndVector, 
00155     Map<RegionQuadCombo, DerivSet>());
00156 
00157   regionQuadComboNonzeroDerivs_.put(VectorOnly, 
00158     Map<RegionQuadCombo, DerivSet>());
00159   bcRegionQuadComboNonzeroDerivs_.put(VectorOnly, 
00160     Map<RegionQuadCombo, DerivSet>());
00161 
00162   if (params.size() > 0) 
00163   {
00164     compTypes_.put(Sensitivities);
00165     rqcToContext_.put(Sensitivities, Map<RegionQuadCombo, EvalContext>());
00166     bcRqcToContext_.put(Sensitivities, Map<RegionQuadCombo, EvalContext>());
00167     regionQuadComboNonzeroDerivs_.put(Sensitivities, 
00168       Map<RegionQuadCombo, DerivSet>());
00169     bcRegionQuadComboNonzeroDerivs_.put(Sensitivities, 
00170       Map<RegionQuadCombo, DerivSet>());
00171   }
00172 
00173   Array<Expr> zero;
00174 
00175   init(zero, flattenSpectral(unkLinearizationPts), unkParamEvalPts_, 
00176     paramEvalPts, fixedFieldValues);
00177 }
00178 
00179 
00180 EquationSet::EquationSet(const Expr& eqns, 
00181   const Expr& bcs,
00182   const Array<Expr>& vars,
00183   const Array<Expr>& varLinearizationPts, 
00184   const Array<Expr>& unks,
00185   const Array<Expr>& unkLinearizationPts, 
00186   const Expr& params,
00187   const Expr& paramEvalPts,
00188   const Array<Expr>& fixedFields,
00189   const Array<Expr>& fixedFieldValues)
00190   : fsr_(),
00191     varUnkPairsOnRegions_(),
00192     bcVarUnkPairsOnRegions_(),
00193     regionQuadCombos_(),
00194     bcRegionQuadCombos_(),
00195     regionQuadComboExprs_(),
00196     bcRegionQuadComboExprs_(),
00197     regionQuadComboNonzeroDerivs_(),
00198     bcRegionQuadComboNonzeroDerivs_(),
00199     rqcToContext_(),
00200     bcRqcToContext_(),
00201     rqcToSkip_(),
00202     bcRqcToSkip_(),
00203     unkLinearizationPts_(flattenSpectral(unkLinearizationPts)),
00204     unkParamEvalPts_(),
00205     fixedParamEvalPts_(paramEvalPts),
00206     compTypes_(),
00207     isNonlinear_(false),
00208     isVariationalProblem_(true),
00209     isFunctionalCalculator_(false),
00210     isSensitivityProblem_(false)
00211 {
00212   Expr unkParams;
00213   fsr_ = rcp(new FunctionSupportResolver(eqns, bcs, vars, 
00214       unks, unkParams, params, fixedFields, 
00215       isVariationalProblem_));
00216 
00217   compTypes_.put(MatrixAndVector);
00218   compTypes_.put(VectorOnly);
00219 
00220   rqcToContext_.put(MatrixAndVector, Map<RegionQuadCombo, EvalContext>());
00221   bcRqcToContext_.put(MatrixAndVector, Map<RegionQuadCombo, EvalContext>());
00222 
00223   rqcToContext_.put(VectorOnly, Map<RegionQuadCombo, EvalContext>());
00224   bcRqcToContext_.put(VectorOnly, Map<RegionQuadCombo, EvalContext>());
00225 
00226   regionQuadComboNonzeroDerivs_.put(MatrixAndVector, 
00227     Map<RegionQuadCombo, DerivSet>());
00228   bcRegionQuadComboNonzeroDerivs_.put(MatrixAndVector, 
00229     Map<RegionQuadCombo, DerivSet>());
00230 
00231   regionQuadComboNonzeroDerivs_.put(VectorOnly, 
00232     Map<RegionQuadCombo, DerivSet>());
00233   bcRegionQuadComboNonzeroDerivs_.put(VectorOnly, 
00234     Map<RegionQuadCombo, DerivSet>());
00235 
00236   init(flattenSpectral(varLinearizationPts), 
00237     flattenSpectral(unkLinearizationPts), 
00238     unkParamEvalPts_, 
00239     paramEvalPts, fixedFieldValues);
00240 }
00241 
00242 EquationSet::EquationSet(const Expr& eqns, 
00243   const Expr& bcs,
00244   const Array<Expr>& vars,
00245   const Array<Expr>& varLinearizationPts, 
00246   const Expr& params,
00247   const Expr& paramEvalPts,
00248   const Array<Expr>& fixedFields,
00249   const Array<Expr>& fixedFieldValues)
00250   : fsr_(),
00251     varUnkPairsOnRegions_(),
00252     bcVarUnkPairsOnRegions_(),
00253     regionQuadCombos_(),
00254     bcRegionQuadCombos_(),
00255     regionQuadComboExprs_(),
00256     bcRegionQuadComboExprs_(),
00257     regionQuadComboNonzeroDerivs_(),
00258     bcRegionQuadComboNonzeroDerivs_(),
00259     rqcToContext_(),
00260     bcRqcToContext_(),
00261     rqcToSkip_(),
00262     bcRqcToSkip_(),
00263     unkLinearizationPts_(),
00264     unkParamEvalPts_(),
00265     fixedParamEvalPts_(paramEvalPts),
00266     compTypes_(),
00267     isNonlinear_(false),
00268     isVariationalProblem_(true),
00269     isFunctionalCalculator_(true),
00270     isSensitivityProblem_(false)
00271 {
00272   compTypes_.put(FunctionalOnly);
00273   compTypes_.put(FunctionalAndGradient);
00274 
00275   Expr unkParams;
00276   Array<Expr> unks;
00277   fsr_ = rcp(new FunctionSupportResolver(eqns, bcs, vars, 
00278       unks, unkParams,
00279       params, fixedFields, isVariationalProblem_));
00280 
00281   rqcToContext_.put(FunctionalAndGradient, Map<RegionQuadCombo, EvalContext>());
00282   bcRqcToContext_.put(FunctionalAndGradient, Map<RegionQuadCombo, EvalContext>());
00283 
00284   rqcToContext_.put(FunctionalOnly, Map<RegionQuadCombo, EvalContext>());
00285   bcRqcToContext_.put(FunctionalOnly, Map<RegionQuadCombo, EvalContext>());
00286 
00287   regionQuadComboNonzeroDerivs_.put(FunctionalAndGradient, 
00288     Map<RegionQuadCombo, DerivSet>());
00289   bcRegionQuadComboNonzeroDerivs_.put(FunctionalAndGradient, 
00290     Map<RegionQuadCombo, DerivSet>());
00291 
00292   regionQuadComboNonzeroDerivs_.put(FunctionalOnly, 
00293     Map<RegionQuadCombo, DerivSet>());
00294   bcRegionQuadComboNonzeroDerivs_.put(FunctionalOnly, 
00295     Map<RegionQuadCombo, DerivSet>());
00296 
00297 
00298   init(flattenSpectral(varLinearizationPts), 
00299     flattenSpectral(unkLinearizationPts_), 
00300     unkParamEvalPts_, 
00301     paramEvalPts, fixedFieldValues);
00302 }
00303 
00304 
00305 
00306 
00307 void EquationSet::init(
00308   const Array<Expr>& varLinearizationPts,
00309   const Array<Expr>& unkLinearizationPts,
00310   const Expr& unkParamEvalPts, 
00311   const Expr& fixedParamEvalPts,
00312   const Array<Expr>& fixedFieldValues)
00313 {
00314   Tabs tab0(0);
00315   Tabs tab1;
00316   bool hasBCs = fsr_->hasBCs();
00317   const SumOfBCs* bcSum = fsr_->bcSum();
00318   const SumOfIntegrals* integralSum = fsr_->integralSum();
00319  
00320   int verb = 0;
00321 
00322   /* upgrade base verbosity level if one of the terms is being watched */
00323   if (integralSum->hasWatchedTerm() || (hasBCs && bcSum->hasWatchedTerm()))
00324   {
00325     int v1 = integralSum->eqnSetSetupVerb();
00326     int v2 = 0;
00327     if (hasBCs) v2 = bcSum->eqnSetSetupVerb();
00328     verb = std::max(v1, v2);
00329   }
00330   SUNDANCE_BANNER1(verb, tab0, "EquationSet setup");
00331 
00332 
00333   /* get symbolic functions from the function support resolver */
00334   const Array<Expr>& unks = fsr_->unks();
00335   const Array<Expr>& vars = fsr_->vars();
00336   const Expr& unkParams = fsr_->unkParams();
00337   const Expr& fixedParams = fsr_->fixedParams();
00338   const Array<Expr>& fixedFields = fsr_->fixedFields();
00339 
00340   SUNDANCE_MSG1(verb, tab0 << "fixed params = " << fixedParams);
00341 
00342   const Set<int>& varFuncSet = fsr_->varFuncSet();
00343   const Set<int>& unkFuncSet = fsr_->unkFuncSet();
00344 
00345   Set<RegionQuadCombo> rqcSet;
00346   Set<RegionQuadCombo> rqcBCSet;
00347 
00348 
00349 
00350   Array<int> contextID = tuple(EvalContext::nextID(),
00351     EvalContext::nextID(),
00352     EvalContext::nextID(),
00353     EvalContext::nextID(),
00354     EvalContext::nextID());
00355 
00356 
00357   /* for each computation type, initialize list of regions to skip */
00358   for (Set<ComputationType>::const_iterator 
00359          i=compTypes_.begin(); i!=compTypes_.end(); i++)
00360   {
00361     rqcToSkip_[*i] = Set<RegionQuadCombo>();
00362     bcRqcToSkip_[*i] = Set<RegionQuadCombo>();
00363   }
00364 
00365   SUNDANCE_MSG1(verb, tab0 << "computation types = " << compTypes_);
00366 
00367 
00368 
00369   /* Now compile a list of all regions appearing in either the eqns or
00370    * the BCs */
00371 
00372   /* Do the non-bc eqns first */
00373   SUNDANCE_MSG1(verb, tab1 << "processing integral terms");
00374   for (Sundance::Map<RegionQuadCombo, Expr>::const_iterator 
00375          r=integralSum->rqcToExprMap().begin(); 
00376        r!=integralSum->rqcToExprMap().end(); r++)
00377   {
00378     Tabs tab15;
00379     Tabs tab2;
00380     RegionQuadCombo rqc = r->first;
00381     int rqcVerb = verb;
00382     int symbVerb = 0;
00383     int evalSetupVerb = 0;
00384     if (rqc.watch().isActive()) 
00385     {
00386       symbVerb = rqc.watch().param("symbolic preprocessing");
00387       rqcVerb=rqc.watch().param("equation set setup");
00388       evalSetupVerb=rqc.watch().param("evaluator setup");
00389     }
00390     SUNDANCE_MSG1(std::max(verb,rqcVerb), tab15 << "processing RQC = " << rqc);
00391 
00392 
00393     rqcSet.put(rqc);
00394     Expr term = r->second;
00395     OrderedHandle<CellFilterStub> reg = rqc.domain();
00396     OrderedHandle<QuadratureFamilyStub> quad = rqc.quad();
00397 
00398     regionQuadComboExprs_.put(rqc, term);
00399 
00400     /* prepare calculation of both stiffness matrix and load vector */
00401     if (compTypes_.contains(MatrixAndVector))
00402     {
00403       SUNDANCE_MSG2(rqcVerb, tab2 << "preparing matrix/vector calculation");
00404       Tabs tab3; 
00405       EvalContext context(rqc, makeSet(1,2), contextID[0]);
00406       context.setSetupVerbosity(symbVerb);
00407       context.setEvalSetupVerbosity(evalSetupVerb);
00408       DerivSet nonzeros;
00409       
00410       if (isVariationalProblem_)
00411       {
00412         nonzeros = SymbPreprocessor
00413           ::setupVariations(term, 
00414             toList(vars), 
00415             toList(varLinearizationPts),
00416             toList(unks), 
00417             toList(unkLinearizationPts),
00418             unkParams, 
00419             unkParamEvalPts,
00420             toList(fixedFields), 
00421             toList(fixedFieldValues),
00422             fixedParams, 
00423             fixedParamEvalPts,
00424             context, 
00425             MatrixAndVector);
00426       }
00427       else
00428       {
00429         nonzeros = SymbPreprocessor
00430           ::setupFwdProblem(term, toList(vars), 
00431             toList(unks), 
00432             toList(unkLinearizationPts),
00433             unkParams, 
00434             unkParamEvalPts,
00435             fixedParams, 
00436             fixedParamEvalPts,
00437             toList(fixedFields), 
00438             toList(fixedFieldValues),
00439             context, 
00440             MatrixAndVector);
00441       }
00442       SUNDANCE_MSG2(rqcVerb, tab3 << "nonzeros are " << nonzeros);
00443       if (nonzeros.size()==0) 
00444       {
00445         rqcToSkip_[MatrixAndVector].put(rqc);
00446       }
00447       else
00448       {
00449         addToVarUnkPairs(rqc.domain(), varFuncSet, unkFuncSet,
00450           nonzeros, false, rqcVerb);
00451         rqcToContext_[MatrixAndVector].put(rqc, context);
00452         regionQuadComboNonzeroDerivs_[MatrixAndVector].put(rqc, 
00453           nonzeros);
00454       }
00455     }
00456 
00457 
00458 
00459     /* prepare calculation of load vector only */
00460     if (compTypes_.contains(VectorOnly))
00461     {
00462       SUNDANCE_MSG2(rqcVerb, tab2 << "preparing vector-only calculation");
00463       Tabs tab3; 
00464       EvalContext context(rqc, makeSet(1), contextID[1]);
00465       context.setSetupVerbosity(symbVerb);
00466       context.setEvalSetupVerbosity(evalSetupVerb);
00467       DerivSet nonzeros;
00468       if (isVariationalProblem_)
00469       {
00470         nonzeros = SymbPreprocessor
00471           ::setupVariations(term, toList(vars), 
00472             toList(varLinearizationPts),
00473             toList(unks), 
00474             toList(unkLinearizationPts),
00475             unkParams, 
00476             unkParamEvalPts,
00477             toList(fixedFields),
00478             toList(fixedFieldValues),
00479             fixedParams, 
00480             fixedParamEvalPts,
00481             context,
00482             VectorOnly);
00483       }
00484       else
00485       {
00486         nonzeros = SymbPreprocessor
00487           ::setupFwdProblem(term, toList(vars), 
00488             toList(unks), 
00489             toList(unkLinearizationPts),
00490             unkParams, 
00491             unkParamEvalPts,
00492             fixedParams, 
00493             fixedParamEvalPts,
00494             toList(fixedFields), 
00495             toList(fixedFieldValues),
00496             context,
00497             VectorOnly);
00498       }
00499       SUNDANCE_MSG2(rqcVerb, tab3 << "nonzeros are " << nonzeros);
00500       if (nonzeros.size()==0) 
00501       {
00502         rqcToSkip_[VectorOnly].put(rqc);
00503       }
00504       else
00505       {
00506         rqcToContext_[VectorOnly].put(rqc, context);
00507         regionQuadComboNonzeroDerivs_[VectorOnly].put(rqc, nonzeros);
00508       }
00509     }
00510 
00511 
00512     /* prepare calculation of sensitivities */
00513     if (compTypes_.contains(Sensitivities))
00514     {
00515       SUNDANCE_MSG2(rqcVerb, tab2 << "preparing sensitivity calculation");
00516       Tabs tab3;
00517       EvalContext context(rqc, makeSet(2), contextID[4]);
00518       context.setSetupVerbosity(symbVerb);
00519       context.setEvalSetupVerbosity(evalSetupVerb);
00520       DerivSet nonzeros;
00521       nonzeros = SymbPreprocessor
00522         ::setupSensitivities(term, toList(vars), 
00523           toList(unks), 
00524           toList(unkLinearizationPts),
00525           unkParams, 
00526           unkParamEvalPts,
00527           fixedParams, 
00528           fixedParamEvalPts,
00529           toList(fixedFields), 
00530           toList(fixedFieldValues),
00531           context,
00532           Sensitivities);
00533       SUNDANCE_MSG2(rqcVerb, tab3 << "nonzeros are " << nonzeros);
00534       if (nonzeros.size()==0) 
00535       {
00536         rqcToSkip_[Sensitivities].put(rqc);
00537       }
00538       else
00539       {
00540         rqcToContext_[Sensitivities].put(rqc, context);
00541         regionQuadComboNonzeroDerivs_[Sensitivities].put(rqc, nonzeros);
00542       }
00543     }
00544 
00545 
00546 
00547     /* prepare calculation of functional value only */
00548     if (compTypes_.contains(FunctionalOnly))
00549     {
00550       SUNDANCE_MSG2(rqcVerb, tab2 << "preparing functional calculation");
00551       Tabs tab3;
00552 
00553       EvalContext context(rqc, makeSet(0), contextID[2]);
00554       context.setSetupVerbosity(symbVerb);
00555       context.setEvalSetupVerbosity(evalSetupVerb);
00556       DerivSet nonzeros;
00557       Expr fields;
00558       Expr fieldValues;
00559       if (fixedFields.size() > 0)
00560       {
00561         if (vars.size() > 0)
00562         {
00563           fields = List(toList(fixedFields), toList(vars));
00564           fields = fields.flatten();
00565         }
00566         else
00567         {
00568           fields = toList(fixedFields);
00569         }
00570       }
00571       else
00572       {
00573         if (vars.size() > 0)
00574         {
00575           fields = toList(vars);
00576         }
00577       }
00578       if (fixedFieldValues.size() > 0)
00579       {
00580         if (varLinearizationPts.size() > 0)
00581         {
00582           fieldValues = List(toList(fixedFieldValues), 
00583             toList(varLinearizationPts));
00584           fieldValues = fieldValues.flatten();
00585         }
00586         else
00587         {
00588           fieldValues = toList(fixedFieldValues);
00589         }
00590       }
00591       else
00592       {
00593         if (varLinearizationPts.size() > 0)
00594         {
00595           fieldValues = toList(varLinearizationPts);
00596         }
00597       }
00598 
00599       nonzeros = SymbPreprocessor
00600         ::setupFunctional(term, 
00601           fixedParams, 
00602           fixedParamEvalPts,
00603           fields,
00604           fieldValues,
00605           context,
00606           FunctionalOnly);
00607       SUNDANCE_MSG2(rqcVerb, tab3 << "nonzeros are " << nonzeros);
00608 
00609       if (nonzeros.size()==0) 
00610       {
00611         rqcToSkip_[FunctionalOnly].put(rqc);
00612       }
00613       else
00614       {
00615         rqcToContext_[FunctionalOnly].put(rqc, context);
00616         regionQuadComboNonzeroDerivs_[FunctionalOnly].put(rqc, nonzeros);
00617       }
00618     }
00619     /* prepare calculation of functional value and gradient */
00620     if (compTypes_.contains(FunctionalAndGradient))
00621     {
00622       SUNDANCE_MSG2(rqcVerb, tab2 << "preparing functional/gradient calculation");
00623       Tabs tab3;
00624       EvalContext context(rqc, makeSet(0,1), contextID[3]);
00625       context.setSetupVerbosity(symbVerb);
00626       context.setEvalSetupVerbosity(evalSetupVerb);
00627       DerivSet nonzeros;
00628       nonzeros = SymbPreprocessor
00629         ::setupGradient(term, 
00630           toList(vars), toList(varLinearizationPts),
00631           fixedParams, 
00632           fixedParamEvalPts,
00633           toList(fixedFields), toList(fixedFieldValues),
00634           context,
00635           FunctionalAndGradient);
00636 
00637       SUNDANCE_MSG2(rqcVerb, tab3 << "nonzeros are " << nonzeros);
00638 
00639       if (nonzeros.size()==0) 
00640       {
00641         rqcToSkip_[FunctionalAndGradient].put(rqc);
00642       }
00643       else
00644       {
00645         rqcToContext_[FunctionalAndGradient].put(rqc, context);
00646         regionQuadComboNonzeroDerivs_[FunctionalAndGradient].put(rqc, nonzeros);
00647       }
00648     }
00649   }
00650   
00651   /* now do the BCs */
00652   if (hasBCs)
00653   {
00654     /* functions found in the BCs both in the overall lists and 
00655      * also in the bc-specific lists */
00656     SUNDANCE_MSG1(verb, tab1 << "processing essential BC terms");
00657     for (Sundance::Map<RegionQuadCombo, Expr>::const_iterator 
00658            r=bcSum->rqcToExprMap().begin(); 
00659          r!=bcSum->rqcToExprMap().end(); r++)
00660     {
00661       Tabs tab15;
00662       RegionQuadCombo rqc = r->first;
00663       int rqcVerb = verb;
00664       int symbVerb = 0;
00665       int evalSetupVerb = 0;
00666       if (rqc.watch().isActive()) 
00667       {
00668         symbVerb = rqc.watch().param("symbolic preprocessing");
00669         rqcVerb=rqc.watch().param("equation set setup");
00670         evalSetupVerb=rqc.watch().param("evaluator setup");
00671       }
00672       SUNDANCE_MSG1(verb, tab15 << "processing BC RQC = " << rqc);
00673 
00674       rqcBCSet.put(rqc);
00675       Expr term = r->second;
00676       OrderedHandle<CellFilterStub> reg = rqc.domain();
00677       OrderedHandle<QuadratureFamilyStub> quad = rqc.quad();
00678 
00679       bcRegionQuadComboExprs_.put(rqc, term); 
00680 
00681 
00682               
00683       /* prepare calculation of both stiffness matrix and load vector */
00684       if (compTypes_.contains(MatrixAndVector))
00685       {
00686         Tabs tab3;
00687         SUNDANCE_MSG2(rqcVerb, tab3 << "preparing matrix/vector calculation");
00688         EvalContext context(rqc, makeSet(1,2), contextID[0]);
00689         context.setSetupVerbosity(symbVerb);
00690         context.setEvalSetupVerbosity(evalSetupVerb);
00691         DerivSet nonzeros;
00692               
00693         if (isVariationalProblem_)
00694         {
00695           nonzeros = SymbPreprocessor
00696             ::setupVariations(term, 
00697               toList(vars), 
00698               toList(varLinearizationPts),
00699               toList(unks), 
00700               toList(unkLinearizationPts),
00701               unkParams, 
00702               unkParamEvalPts,
00703               toList(fixedFields), 
00704               toList(fixedFieldValues),
00705               fixedParams, 
00706               fixedParamEvalPts,
00707               context,
00708               MatrixAndVector);
00709         }
00710         else
00711         {
00712           nonzeros = SymbPreprocessor
00713             ::setupFwdProblem(term, toList(vars), toList(unks), 
00714               toList(unkLinearizationPts),
00715               unkParams, 
00716               unkParamEvalPts,
00717               fixedParams, 
00718               fixedParamEvalPts,
00719               toList(fixedFields), 
00720               toList(fixedFieldValues),
00721               context,
00722               MatrixAndVector);
00723         }
00724         SUNDANCE_MSG2(rqcVerb, tab3 << "nonzeros are " << nonzeros);
00725         if (nonzeros.size()==0) 
00726         {
00727           bcRqcToSkip_[MatrixAndVector].put(rqc);
00728         }
00729         else
00730         {
00731           addToVarUnkPairs(rqc.domain(), varFuncSet, unkFuncSet,
00732             nonzeros, true, rqcVerb);
00733           bcRqcToContext_[MatrixAndVector].put(rqc, context);
00734           bcRegionQuadComboNonzeroDerivs_[MatrixAndVector].put(rqc, 
00735             nonzeros);
00736         }
00737       }
00738 
00739 
00740 
00741 
00742 
00743       /* prepare calculation of load vector only */
00744       if (compTypes_.contains(VectorOnly))
00745       {
00746         Tabs tab3;
00747         SUNDANCE_MSG2(rqcVerb, tab3 << "preparing vector-only calculation");
00748         EvalContext context(rqc, makeSet(1), contextID[1]);
00749         context.setSetupVerbosity(symbVerb);
00750         context.setEvalSetupVerbosity(evalSetupVerb);
00751         DerivSet nonzeros;
00752         if (isVariationalProblem_)
00753         {
00754           nonzeros = SymbPreprocessor
00755             ::setupVariations(term, toList(vars), 
00756               toList(varLinearizationPts),
00757               toList(unks), 
00758               toList(unkLinearizationPts),
00759               unkParams, 
00760               unkParamEvalPts,
00761               toList(fixedFields), 
00762               toList(fixedFieldValues),
00763               fixedParams, 
00764               fixedParamEvalPts,
00765               context,
00766               VectorOnly);
00767         }
00768         else
00769         {
00770           nonzeros = SymbPreprocessor
00771             ::setupFwdProblem(term, toList(vars), toList(unks), 
00772               toList(unkLinearizationPts),
00773               unkParams, 
00774               unkParamEvalPts,
00775               fixedParams, 
00776               fixedParamEvalPts,
00777               toList(fixedFields), 
00778               toList(fixedFieldValues),
00779               context,
00780               VectorOnly);
00781         }
00782         SUNDANCE_MSG2(rqcVerb, tab3 << "nonzeros are " << nonzeros);
00783         if (nonzeros.size()==0) 
00784         {
00785           bcRqcToSkip_[VectorOnly].put(rqc);
00786         }
00787         else
00788         {
00789           bcRqcToContext_[VectorOnly].put(rqc, context);
00790           bcRegionQuadComboNonzeroDerivs_[VectorOnly].put(rqc, nonzeros);
00791         }
00792       }
00793 
00794 
00795 
00796 
00797 
00798 
00799 
00800 
00801       /* prepare calculation of sensitivities */
00802       if (compTypes_.contains(Sensitivities))
00803       {
00804         Tabs tab3;
00805         SUNDANCE_MSG2(rqcVerb, tab3 << "preparing sensitivity calculation");
00806         EvalContext context(rqc, makeSet(2), contextID[4]);
00807         context.setSetupVerbosity(symbVerb);
00808         context.setEvalSetupVerbosity(evalSetupVerb);
00809         DerivSet nonzeros;
00810         nonzeros = SymbPreprocessor
00811           ::setupSensitivities(term, toList(vars), toList(unks), 
00812             toList(unkLinearizationPts),
00813             unkParams, 
00814             unkParamEvalPts,
00815             fixedParams, 
00816             fixedParamEvalPts,
00817             toList(fixedFields), 
00818             toList(fixedFieldValues),
00819             context,
00820             Sensitivities);
00821 
00822         SUNDANCE_MSG2(rqcVerb, tab3 << "nonzeros are " << nonzeros);
00823         if (nonzeros.size()==0) 
00824         {
00825           bcRqcToSkip_[Sensitivities].put(rqc);
00826         }
00827         else
00828         {
00829           bcRqcToContext_[Sensitivities].put(rqc, context);
00830           bcRegionQuadComboNonzeroDerivs_[Sensitivities].put(rqc, nonzeros);
00831         }
00832       }
00833 
00834 
00835 
00836 
00837 
00838 
00839 
00840       /* prepare calculation of functional value only */
00841       if (compTypes_.contains(FunctionalOnly))
00842       {
00843         Tabs tab3;
00844         SUNDANCE_MSG2(rqcVerb, tab3 << "preparing functional-only calculation");
00845         EvalContext context(rqc, makeSet(0), contextID[2]);
00846         context.setSetupVerbosity(symbVerb);
00847         context.setEvalSetupVerbosity(evalSetupVerb);
00848         DerivSet nonzeros;
00849         Expr fields;
00850         Expr fieldValues;
00851         if (fixedFields.size() > 0)
00852         {
00853           if (vars.size() > 0)
00854           {
00855             fields = List(toList(fixedFields), toList(vars));
00856             fields = fields.flatten();
00857           }
00858           else
00859           {
00860             fields = toList(fixedFields);
00861           }
00862         }
00863         else
00864         {
00865           if (vars.size() > 0)
00866           {
00867             fields = toList(vars);
00868           }
00869         }
00870         if (fixedFieldValues.size() > 0)
00871         {
00872           if (varLinearizationPts.size() > 0)
00873           {
00874             fieldValues = List(toList(fixedFieldValues), 
00875               toList(varLinearizationPts));
00876             fieldValues = fieldValues.flatten();
00877           }
00878           else
00879           {
00880             fieldValues = toList(fixedFieldValues);
00881           }
00882         }
00883         else
00884         {
00885           if (varLinearizationPts.size() > 0)
00886           {
00887             fieldValues = toList(varLinearizationPts);
00888           }
00889         }
00890         nonzeros = SymbPreprocessor
00891           ::setupFunctional(term, 
00892             fixedParams, 
00893             fixedParamEvalPts,
00894             fields, fieldValues,
00895             context,
00896             FunctionalOnly);
00897 
00898         SUNDANCE_MSG2(rqcVerb, tab3 << "nonzeros are " << nonzeros);                  
00899         if (nonzeros.size()==0) 
00900         {
00901           bcRqcToSkip_[FunctionalOnly].put(rqc);
00902         }
00903         else
00904         {
00905           bcRqcToContext_[FunctionalOnly].put(rqc, context);
00906           bcRegionQuadComboNonzeroDerivs_[FunctionalOnly].put(rqc, nonzeros);
00907         }
00908       }
00909 
00910 
00911 
00912 
00913       /* prepare calculation of functional value and gradient */
00914       if (compTypes_.contains(FunctionalAndGradient))
00915       {
00916         Tabs tab3;
00917         SUNDANCE_MSG2(rqcVerb, tab3 << "preparing functional and gradient calculation");
00918         EvalContext context(rqc, makeSet(0,1), contextID[3]);
00919         context.setSetupVerbosity(symbVerb);
00920         context.setEvalSetupVerbosity(evalSetupVerb);
00921         DerivSet nonzeros;
00922         nonzeros = SymbPreprocessor
00923           ::setupGradient(term, 
00924             toList(vars), 
00925             toList(varLinearizationPts),
00926             fixedParams, 
00927             fixedParamEvalPts,
00928             toList(fixedFields), 
00929             toList(fixedFieldValues),
00930             context,
00931             FunctionalAndGradient);
00932 
00933         SUNDANCE_MSG2(rqcVerb, tab3 << "nonzeros are " << nonzeros);
00934         if (nonzeros.size()==0) 
00935         {
00936           bcRqcToSkip_[FunctionalAndGradient].put(rqc);
00937         }
00938         else
00939         {
00940           bcRqcToContext_[FunctionalAndGradient].put(rqc, context);
00941           bcRegionQuadComboNonzeroDerivs_[FunctionalAndGradient].put(rqc, nonzeros);
00942         }
00943       }
00944     }
00945   }
00946 
00947   
00948 
00949 
00950   /* convert sets to arrays */
00951   regionQuadCombos_ = rqcSet.elements();
00952   bcRegionQuadCombos_ = rqcBCSet.elements();
00953 
00954   
00955 
00956 
00957 }
00958 
00959 
00960 void EquationSet
00961 ::addToVarUnkPairs(const OrderedHandle<CellFilterStub>& domain,
00962   const Set<int>& vars,
00963   const Set<int>& unks,
00964   const DerivSet& nonzeros, 
00965   bool isBC,
00966   int verb)
00967 {
00968   Tabs tab;
00969   SUNDANCE_MSG2(verb, tab << "finding var-unk pairs "
00970     "for domain " << domain);
00971   SUNDANCE_MSG2(verb, tab << "isBC=" << isBC);
00972   
00973   RCP<Set<OrderedPair<int, int> > > funcPairs;
00974   Map<OrderedHandle<CellFilterStub>, RCP<Set<OrderedPair<int, int> > > >* theMap;
00975 
00976   if (isBC) 
00977   {
00978     theMap = &(bcVarUnkPairsOnRegions_);
00979   }
00980   else 
00981   {
00982     theMap = &(varUnkPairsOnRegions_);
00983   } 
00984 
00985   if (theMap->containsKey(domain))
00986   {
00987     funcPairs = theMap->get(domain);
00988   }
00989   else
00990   {
00991     funcPairs = rcp(new Set<OrderedPair<int, int> >());
00992     theMap->put(domain, funcPairs);
00993   }
00994 
00995   for (DerivSet::const_iterator i=nonzeros.begin(); i!=nonzeros.end(); i++)
00996   {
00997     Tabs tab1;
00998     const MultipleDeriv& md = *i;
00999     if (md.order() != 2) continue;
01000       
01001     Array<Deriv> f;
01002     for (MultipleDeriv::const_iterator j=md.begin(); j != md.end(); j++)
01003     {
01004       const Deriv& d = *j;
01005       TEUCHOS_TEST_FOR_EXCEPTION(!d.isFunctionalDeriv(), 
01006         std::logic_error, "non-functional deriv "
01007         << d << " detected in EquationSet::"
01008         "addToVarUnkPairs()");
01009       f.append(d);
01010     }
01011 
01012     SUNDANCE_MSG2(verb, tab1 << "f1=" << f[0].dofID()
01013       << ", f2=" << f[1].dofID() << ", vars=" << vars 
01014       << ", unks=" << unks);
01015     
01016     bool gotIt=false;
01017     if (unks.contains(f[0].dofID())
01018       && vars.contains(f[1].dofID()))
01019     {
01020       int unkID = f[0].dofID();
01021       int varID = f[1].dofID();
01022       funcPairs->put(OrderedPair<int, int>(varID, unkID));
01023       gotIt=true;
01024     }
01025     if (unks.contains(f[1].dofID())
01026       && vars.contains(f[0].dofID()))
01027     {
01028       int unkID = f[1].dofID();
01029       int varID = f[0].dofID();
01030       funcPairs->put(OrderedPair<int, int>(varID, unkID));
01031       gotIt=true;
01032     }
01033     TEUCHOS_TEST_FOR_EXCEPTION(!gotIt, std::logic_error,
01034       "no valid (var,unk) pair could be extracted from "
01035       "derivative " << md);
01036   }
01037 
01038   SUNDANCE_MSG2(verb, tab << "found " << *funcPairs);
01039   
01040 }
01041 
01042 bool EquationSet::hasActiveWatchFlag() const 
01043 {
01044   for (int i=0; i<regionQuadCombos().size(); i++)
01045   {
01046     if (regionQuadCombos()[i].watch().isActive()) return true;
01047   }
01048   for (int i=0; i<bcRegionQuadCombos().size(); i++)
01049   {
01050     if (bcRegionQuadCombos()[i].watch().isActive()) return true;
01051   }
01052   return false;
01053 }
01054 
01055 
01056 int EquationSet::maxWatchFlagSetting(const std::string& param) const 
01057 {
01058   int rtn = 0;
01059   if (!hasActiveWatchFlag()) return 0;
01060   for (int i=0; i<regionQuadCombos().size(); i++)
01061   {
01062     int v = regionQuadCombos()[i].watch().param(param);
01063     if (v > rtn) rtn = v;
01064   }
01065   for (int i=0; i<bcRegionQuadCombos().size(); i++)
01066   {
01067     int v = bcRegionQuadCombos()[i].watch().param(param);
01068     if (v > rtn) rtn = v;
01069   }
01070   return rtn;
01071 }
01072 
01073 Array<Expr> EquationSet::flattenSpectral(const Array<Expr>& expr) const
01074 {
01075   Array<Expr> rtn(expr.size());
01076   for (int i=0; i<expr.size(); i++)
01077   {
01078     const Expr& e = expr[i];
01079     rtn[i] = flattenSpectral(e);
01080   }
01081   return rtn;
01082 }
01083 
01084 Expr EquationSet::flattenSpectral(const Expr& expr) const
01085 {
01086   Array<Expr> rtn(expr.size());
01087   for (int i=0; i<expr.size(); i++)
01088   {
01089     if (expr[i].size() == 1)
01090     {
01091       const SpectralExpr* se 
01092         = dynamic_cast<const SpectralExpr*>(expr[i][0].ptr().get());
01093       if (se != 0)
01094       {
01095         int nt = se->getSpectralBasis().nterms();
01096         Array<Expr> e(nt);
01097         for (int j=0; j<nt; j++)
01098         {
01099           e[j] = se->getCoeff(j);
01100         }
01101         rtn[i] = new ListExpr(e);
01102       }
01103       else
01104       {
01105         rtn[i] = expr[i];
01106       }
01107     }
01108     else
01109     {
01110       rtn[i] = flattenSpectral(expr[i]);
01111     }
01112   }
01113   Expr r = new ListExpr(rtn);
01114   return r.flatten();
01115                   
01116 }
01117 
01118 const RCP<Set<OrderedPair<int, int> > >& EquationSet::
01119 bcVarUnkPairs(const OrderedHandle<CellFilterStub>& domain) const 
01120 {
01121   TEUCHOS_TEST_FOR_EXCEPTION(!bcVarUnkPairsOnRegions_.containsKey(domain),
01122     std::logic_error,
01123     "equation set does not have a var-unk pair list for "
01124     "bc region " << domain);
01125   const RCP<Set<OrderedPair<int, int> > >& rtn 
01126     = bcVarUnkPairsOnRegions_.get(domain);
01127 
01128   TEUCHOS_TEST_FOR_EXCEPTION(rtn.get()==0, std::logic_error, 
01129     "null var-unk pair list for BC region " << domain);
01130   return rtn;
01131 }
01132 
01133 bool EquationSet::isBCRegion(int d) const
01134 {
01135   return fsr_->isBCRegion(d);
01136 }
01137 
01138 
01139 EvalContext EquationSet::rqcToContext(ComputationType compType, 
01140   const RegionQuadCombo& r) const 
01141 {
01142   TEUCHOS_TEST_FOR_EXCEPTION(!rqcToContext_.containsKey(compType),
01143     std::logic_error,
01144     "EquationSet::rqcToContext() did not find key " 
01145     << compType);
01146   TEUCHOS_TEST_FOR_EXCEPTION(!rqcToContext_.get(compType).containsKey(r),
01147     std::logic_error, 
01148     "EquationSet::rqcToContext(" << compType 
01149     << ") did not find expected key " 
01150     << r);
01151     
01152   return rqcToContext_.get(compType).get(r);
01153 }
01154 
01155 EvalContext EquationSet::bcRqcToContext(ComputationType compType, 
01156   const RegionQuadCombo& r) const 
01157 {
01158   TEUCHOS_TEST_FOR_EXCEPTION(!bcRqcToContext_.containsKey(compType),
01159     std::logic_error,
01160     "EquationSet::bcRqcToContext() did not find key " 
01161     << compType);
01162   TEUCHOS_TEST_FOR_EXCEPTION(!bcRqcToContext_.get(compType).containsKey(r),
01163     std::logic_error, 
01164     "EquationSet::bcRqcToContext(" << compType 
01165     << ") did not find expected key " 
01166     << r);
01167   return bcRqcToContext_.get(compType).get(r);
01168 }
01169 
01170 
01171 bool EquationSet::skipRqc(ComputationType compType, 
01172   const RegionQuadCombo& r) const 
01173 {
01174   TEUCHOS_TEST_FOR_EXCEPTION(!rqcToSkip_.containsKey(compType),
01175     std::logic_error,
01176     "EquationSet::skipRqc() did not find expected key " 
01177     << compType);
01178     
01179   return rqcToSkip_.get(compType).contains(r);
01180 }
01181 
01182 bool EquationSet::skipBCRqc(ComputationType compType, 
01183   const RegionQuadCombo& r) const 
01184 {
01185   TEUCHOS_TEST_FOR_EXCEPTION(!bcRqcToSkip_.containsKey(compType),
01186     std::logic_error,
01187     "EquationSet::skipBCRqc() did not find expected key " 
01188     << compType);
01189     
01190   return bcRqcToSkip_.get(compType).contains(r);
01191 }
01192 
01193 const DerivSet& EquationSet::nonzeroFunctionalDerivs(ComputationType compType,
01194   const RegionQuadCombo& r) const
01195 {
01196   TEUCHOS_TEST_FOR_EXCEPTION(!regionQuadComboNonzeroDerivs_.containsKey(compType),
01197     std::logic_error,
01198     "EquationSet:nonzeroFunctionalDerivs() did not find key " 
01199     << compType);
01200   return regionQuadComboNonzeroDerivs_.get(compType).get(r);
01201 }
01202 
01203 const DerivSet& EquationSet::nonzeroBCFunctionalDerivs(ComputationType compType,
01204   const RegionQuadCombo& r) const
01205 {
01206   TEUCHOS_TEST_FOR_EXCEPTION(!bcRegionQuadComboNonzeroDerivs_.containsKey(compType),
01207     std::logic_error,
01208     "EquationSet:nonzeroBCFunctionalDerivs() did not find key " 
01209     << compType);
01210   return bcRegionQuadComboNonzeroDerivs_.get(compType).get(r);
01211 }
01212 
01213 
01214 
01215 int EquationSet::reducedVarID(int varID) const 
01216 {
01217   return fsr_->reducedVarID(varID);
01218 }
01219 
01220 int EquationSet::reducedUnkID(int unkID) const 
01221 {
01222   return fsr_->reducedUnkID(unkID);
01223 }
01224 
01225 
01226 int EquationSet::reducedUnkParamID(int unkParamID) const 
01227 {
01228   return fsr_->reducedUnkParamID(unkParamID);
01229 }
01230 
01231 int EquationSet::reducedFixedParamID(int paramID) const 
01232 {
01233   return fsr_->reducedFixedParamID(paramID);
01234 }
01235 
01236 
01237 Expr EquationSet::toList(const Array<Expr>& e)
01238 {
01239   return new ListExpr(e);
01240 }
01241 
01242 
01243 int EquationSet::blockForVarID(int varID) const 
01244 {
01245   return fsr_->blockForVarID(varID);
01246 }
01247 
01248 int EquationSet::blockForUnkID(int unkID) const 
01249 {
01250   return fsr_->blockForUnkID(unkID);
01251 }
01252 
01253 const Set<OrderedHandle<CellFilterStub> >&  EquationSet::regionsForTestFunc(int testID) const
01254 {
01255   return fsr_->regionsForTestFunc(testID);
01256 }
01257 
01258 const Set<OrderedHandle<CellFilterStub> >&  EquationSet::regionsForUnkFunc(int unkID) const
01259 {
01260   return fsr_->regionsForUnkFunc(unkID);
01261 }
01262 
01263 int EquationSet::indexForRegion(const OrderedHandle<CellFilterStub>& region) const
01264 {
01265   return fsr_->indexForRegion(region);
01266 }
01267 
01268 int EquationSet::numRegions() const {return fsr_->numRegions();}
01269 
01270 const RCP<CellFilterStub>& EquationSet::region(int d) const 
01271 {return fsr_->region(d);}
01272 
01273 
01274 
01275 /* Returns the number of variational function blocks */
01276 int EquationSet::numVarBlocks() const 
01277 {return fsr_->numVarBlocks();}
01278 
01279 /* Returns the number of unknown function blocks */
01280 int EquationSet::numUnkBlocks() const 
01281 {return fsr_->numUnkBlocks();}
01282 
01283 /* Returns the number of unknown parameters */
01284 int EquationSet::numUnkParams() const 
01285 {return fsr_->numUnkParams();}
01286 
01287 /* Returns the number of fixed parameters */
01288 int EquationSet::numFixedParams() const 
01289 {return fsr_->numFixedParams();}
01290 
01291 /* Returns the number of variational functions in this block */
01292 int EquationSet::numVars(int block) const 
01293 {return fsr_->numVars(block);}
01294 
01295 /* Returns the number of unk functions in this block */
01296 int EquationSet::numUnks(int block) const 
01297 {return fsr_->numUnks(block);}
01298 
01299 /* Returns the number of variational function IDs in this block */
01300 int EquationSet::numVarIDs(int block) const 
01301 {return fsr_->numVarIDs(block);}
01302 
01303 /* Returns the number of unk function IDs in this block */
01304 int EquationSet::numUnkIDs(int block) const 
01305 {return fsr_->numUnkIDs(block);}
01306 
01307 /* Returns the i-th variational function in block b */
01308 RCP<const CommonFuncDataStub>  EquationSet::varFuncData(int b, int i) const 
01309 {return fsr_->varFuncData(b,i);}
01310     
01311 
01312 /* Returns the i-th unknown function in block b */
01313 RCP<const CommonFuncDataStub>  EquationSet::unkFuncData(int b, int i) const 
01314 {return fsr_->unkFuncData(b,i);}
01315 
01316 /* Returns the i-th unknown parameter */
01317 const Expr& EquationSet::unkParam(int i) const 
01318 {return fsr_->unkParam(i);}
01319 
01320 /* Determine whether a given func ID is listed as a 
01321  * variational function in this equation set */
01322 bool EquationSet::hasVarID(int fid) const 
01323 {return fsr_->hasVarID(fid);}
01324 
01325 /* Determine whether a given func ID is listed as a unk function 
01326  * in this equation set */
01327 bool EquationSet::hasUnkID(int fid) const 
01328 {return fsr_->hasUnkID(fid);}
01329 
01330 /* Determine whether a given func ID is listed as a unk parameter 
01331  * in this equation set */
01332 bool EquationSet::hasUnkParamID(int fid) const 
01333 {return fsr_->hasUnkParamID(fid);}
01334 
01335 /* Determine whether a given func ID is listed as a fixed parameter 
01336  * in this equation set */
01337 bool EquationSet::hasFixedParamID(int fid) const 
01338 {return fsr_->hasFixedParamID(fid);}
01339 
01340  
01341 /* Returns the variational functions that appear explicitly
01342  * on the d-th region */
01343 const Set<int>& EquationSet::varsOnRegion(int d) const 
01344 {return fsr_->varsOnRegion(d);}
01345 
01346 /* Returns the unknown functions that appear explicitly on the
01347  * d-th region. */
01348 const Set<int>& EquationSet::unksOnRegion(int d) const 
01349 {return fsr_->unksOnRegion(d);}
01350 
01351 /* Returns the variational functions that 
01352  * appear in BCs on the d-th region.
01353  * We can use this information to tag certain rows as BC rows */
01354 const Set<int>& EquationSet::bcVarsOnRegion(int d) const 
01355 {return fsr_->bcVarsOnRegion(d);}
01356 
01357 /* Returns the unknown functions that appear in BCs on the d-th region.
01358  * We can use this information to tag certain columns as BC
01359  * columns in the event we're doing symmetrized BC application */
01360 const Set<int>& EquationSet::bcUnksOnRegion(int d) const 
01361 {return fsr_->bcUnksOnRegion(d);}
01362 
01363 /* Returns the reduced variational functions that appear explicitly
01364  * on the d-th region */
01365 const Array<Set<int> >& EquationSet::reducedVarsOnRegion(const OrderedHandle<CellFilterStub>& r) const 
01366 {return fsr_->reducedVarsOnRegion(r);}
01367 
01368 /* Returns the reduced unknown functions that appear explicitly on the
01369  * d-th region. */
01370 const Array<Set<int> >& EquationSet::reducedUnksOnRegion(const OrderedHandle<CellFilterStub>& r) const 
01371 {return fsr_->reducedVarsOnRegion(r);}
01372 
01373 
01374 /** get the unreduced funcID for a variational function
01375  * as specified by a reduced ID and block index */
01376 int EquationSet::unreducedVarID(int block, int reducedVarID) const 
01377 {return fsr_->unreducedVarID(block, reducedVarID);}
01378 
01379 /** get the unreduced funcID for an unknown function
01380  * as specified by a reduced ID and block index */
01381 int EquationSet::unreducedUnkID(int block, int reducedUnkID) const 
01382 {return fsr_->unreducedUnkID(block, reducedUnkID);}
01383 
01384 
01385 /** get the unreduced funcID for an unknown parameter
01386  * as specified by a reduced ID */
01387 int EquationSet::unreducedUnkParamID(int reducedUnkParamID) const 
01388 {return fsr_->unreducedUnkParamID(reducedUnkParamID);}
01389 
01390 
01391 /** get the unreduced funcID for a fixed parameter
01392  * as specified by a reduced ID */
01393 int EquationSet::unreducedFixedParamID(int reducedParamID) const 
01394 {return fsr_->unreducedFixedParamID(reducedParamID);}
01395
SundanceEquationSet.cpp
