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 "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
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
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
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
00370
00371
00372
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
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
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
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
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
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
00652 if (hasBCs)
00653 {
00654
00655
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
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
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
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
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
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
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
01276 int EquationSet::numVarBlocks() const
01277 {return fsr_->numVarBlocks();}
01278
01279
01280 int EquationSet::numUnkBlocks() const
01281 {return fsr_->numUnkBlocks();}
01282
01283
01284 int EquationSet::numUnkParams() const
01285 {return fsr_->numUnkParams();}
01286
01287
01288 int EquationSet::numFixedParams() const
01289 {return fsr_->numFixedParams();}
01290
01291
01292 int EquationSet::numVars(int block) const
01293 {return fsr_->numVars(block);}
01294
01295
01296 int EquationSet::numUnks(int block) const
01297 {return fsr_->numUnks(block);}
01298
01299
01300 int EquationSet::numVarIDs(int block) const
01301 {return fsr_->numVarIDs(block);}
01302
01303
01304 int EquationSet::numUnkIDs(int block) const
01305 {return fsr_->numUnkIDs(block);}
01306
01307
01308 RCP<const CommonFuncDataStub> EquationSet::varFuncData(int b, int i) const
01309 {return fsr_->varFuncData(b,i);}
01310
01311
01312
01313 RCP<const CommonFuncDataStub> EquationSet::unkFuncData(int b, int i) const
01314 {return fsr_->unkFuncData(b,i);}
01315
01316
01317 const Expr& EquationSet::unkParam(int i) const
01318 {return fsr_->unkParam(i);}
01319
01320
01321
01322 bool EquationSet::hasVarID(int fid) const
01323 {return fsr_->hasVarID(fid);}
01324
01325
01326
01327 bool EquationSet::hasUnkID(int fid) const
01328 {return fsr_->hasUnkID(fid);}
01329
01330
01331
01332 bool EquationSet::hasUnkParamID(int fid) const
01333 {return fsr_->hasUnkParamID(fid);}
01334
01335
01336
01337 bool EquationSet::hasFixedParamID(int fid) const
01338 {return fsr_->hasFixedParamID(fid);}
01339
01340
01341
01342
01343 const Set<int>& EquationSet::varsOnRegion(int d) const
01344 {return fsr_->varsOnRegion(d);}
01345
01346
01347
01348 const Set<int>& EquationSet::unksOnRegion(int d) const
01349 {return fsr_->unksOnRegion(d);}
01350
01351
01352
01353
01354 const Set<int>& EquationSet::bcVarsOnRegion(int d) const
01355 {return fsr_->bcVarsOnRegion(d);}
01356
01357
01358
01359
01360 const Set<int>& EquationSet::bcUnksOnRegion(int d) const
01361 {return fsr_->bcUnksOnRegion(d);}
01362
01363
01364
01365 const Array<Set<int> >& EquationSet::reducedVarsOnRegion(const OrderedHandle<CellFilterStub>& r) const
01366 {return fsr_->reducedVarsOnRegion(r);}
01367
01368
01369
01370 const Array<Set<int> >& EquationSet::reducedUnksOnRegion(const OrderedHandle<CellFilterStub>& r) const
01371 {return fsr_->reducedVarsOnRegion(r);}
01372
01373
01374
01375
01376 int EquationSet::unreducedVarID(int block, int reducedVarID) const
01377 {return fsr_->unreducedVarID(block, reducedVarID);}
01378
01379
01380
01381 int EquationSet::unreducedUnkID(int block, int reducedUnkID) const
01382 {return fsr_->unreducedUnkID(block, reducedUnkID);}
01383
01384
01385
01386
01387 int EquationSet::unreducedUnkParamID(int reducedUnkParamID) const
01388 {return fsr_->unreducedUnkParamID(reducedUnkParamID);}
01389
01390
01391
01392
01393 int EquationSet::unreducedFixedParamID(int reducedParamID) const
01394 {return fsr_->unreducedFixedParamID(reducedParamID);}
01395