Esempio n. 1
0
 public CrankNicolsonScheme(double theta,
                            FdmLinearOpComposite map,
                            List <BoundaryCondition <FdmLinearOp> > bcSet = null,
                            double relTol = 1E-8,
                            ImplicitEulerScheme.SolverType solverType = ImplicitEulerScheme.SolverType.BiCGstab)
 {
     dt_       = null;
     theta_    = theta;
     explicit_ = new ExplicitEulerScheme(map, bcSet);
     implicit_ = new ImplicitEulerScheme(map, bcSet, relTol, solverType);
 }
Esempio n. 2
0
        public void rollback(ref object a,
                             double from, double to,
                             int steps, int dampingSteps)
        {
            double deltaT    = from - to;
            int    allSteps  = steps + dampingSteps;
            double dampingTo = from - (deltaT * dampingSteps) / allSteps;

            if (dampingSteps > 0 &&
                schemeDesc_.type != FdmSchemeDesc.FdmSchemeType.ImplicitEulerType)
            {
                ImplicitEulerScheme implicitEvolver = new ImplicitEulerScheme(map_, bcSet_);
                FiniteDifferenceModel <ImplicitEulerScheme> dampingModel
                    = new FiniteDifferenceModel <ImplicitEulerScheme>(implicitEvolver, condition_.stoppingTimes());

                dampingModel.rollback(ref a, from, dampingTo,
                                      dampingSteps, condition_);
            }

            switch (schemeDesc_.type)
            {
            case FdmSchemeDesc.FdmSchemeType.HundsdorferType:
            {
                HundsdorferScheme hsEvolver = new HundsdorferScheme(schemeDesc_.theta, schemeDesc_.mu,
                                                                    map_, bcSet_);
                FiniteDifferenceModel <HundsdorferScheme>
                hsModel = new FiniteDifferenceModel <HundsdorferScheme>(hsEvolver, condition_.stoppingTimes());
                hsModel.rollback(ref a, dampingTo, to, steps, condition_);
            }
            break;

            case FdmSchemeDesc.FdmSchemeType.DouglasType:
            {
                DouglasScheme dsEvolver = new DouglasScheme(schemeDesc_.theta, map_, bcSet_);
                FiniteDifferenceModel <DouglasScheme>
                dsModel = new FiniteDifferenceModel <DouglasScheme>(dsEvolver, condition_.stoppingTimes());
                dsModel.rollback(ref a, dampingTo, to, steps, condition_);
            }
            break;

            case FdmSchemeDesc.FdmSchemeType.CraigSneydType:
            {
                CraigSneydScheme csEvolver = new CraigSneydScheme(schemeDesc_.theta, schemeDesc_.mu,
                                                                  map_, bcSet_);
                FiniteDifferenceModel <CraigSneydScheme>
                csModel = new FiniteDifferenceModel <CraigSneydScheme>(csEvolver, condition_.stoppingTimes());
                csModel.rollback(ref a, dampingTo, to, steps, condition_);
            }
            break;

            case FdmSchemeDesc.FdmSchemeType.ModifiedCraigSneydType:
            {
                ModifiedCraigSneydScheme csEvolver = new ModifiedCraigSneydScheme(schemeDesc_.theta,
                                                                                  schemeDesc_.mu,
                                                                                  map_, bcSet_);
                FiniteDifferenceModel <ModifiedCraigSneydScheme>
                mcsModel = new FiniteDifferenceModel <ModifiedCraigSneydScheme>(csEvolver, condition_.stoppingTimes());
                mcsModel.rollback(ref a, dampingTo, to, steps, condition_);
            }
            break;

            case FdmSchemeDesc.FdmSchemeType.ImplicitEulerType:
            {
                ImplicitEulerScheme implicitEvolver = new ImplicitEulerScheme(map_, bcSet_);
                FiniteDifferenceModel <ImplicitEulerScheme>
                implicitModel = new FiniteDifferenceModel <ImplicitEulerScheme>(implicitEvolver, condition_.stoppingTimes());
                implicitModel.rollback(ref a, from, to, allSteps, condition_);
            }
            break;

            case FdmSchemeDesc.FdmSchemeType.ExplicitEulerType:
            {
                ExplicitEulerScheme explicitEvolver = new ExplicitEulerScheme(map_, bcSet_);
                FiniteDifferenceModel <ExplicitEulerScheme>
                explicitModel = new FiniteDifferenceModel <ExplicitEulerScheme>(explicitEvolver, condition_.stoppingTimes());
                explicitModel.rollback(ref a, dampingTo, to, steps, condition_);
            }
            break;

            default:
                Utils.QL_FAIL("Unknown scheme type");
                break;
            }
        }