## -----------------------------------------------------------------------------
#| echo: true
library(rpact)
designGS <- getDesignGroupSequential(
    kMax = 2,
    typeOfDesign = "asOF",
    beta = 0.1
)
designGS


## -----------------------------------------------------------------------------
#| echo: false
#| eval: true
setOutputFormat(resetToDefault = TRUE)


## -----------------------------------------------------------------------------
#| echo: true
sampleSize <- designGS |>
    getSampleSizeSurvival(
        lambda1 = getLambdaByMedian(18),
        lambda2 = log(2) / 12,
        dropoutRate1 = 0.05,
        dropoutRate2 = 0.05,
        dropoutTime = 12,
        accrualTime = 12,
        followUpTime = 12
    )
sampleSize |> summary()


## -----------------------------------------------------------------------------
#| echo: true
ceiling(sampleSize$maxNumberOfEvents) # how many events?
ceiling(sampleSize$maxNumberOfSubjects) # how many subjects?
ceiling(sampleSize$maxNumberOfSubjects) / 12 # accrual per month?
round(sampleSize$cumulativeEventsPerStage[1, 1], 1) # IA at how many events?
round(sampleSize$analysisTime[1, 1], 2) # When is the IA?


## -----------------------------------------------------------------------------
#| echo: true
setOutputFormat("maxNumberOfSubjects",
    digits = 0,
    nsmall = 0, roundFunction = "ceiling"
)


## -----------------------------------------------------------------------------
#| echo: true
designGS |>
    getSampleSizeSurvival(
        median1 = 18,
        median2 = 12,
        dropoutRate1 = 0.05,
        dropoutRate2 = 0.05,
        dropoutTime = 12,
        accrualTime = c(0, 16), # not just 16 here!
        accrualIntensity = 25
    ) |>
    fetch(
        maxNumberOfSubjects,
        followUpTime,
        analysisTime
    )


## -----------------------------------------------------------------------------
#| echo: true
designGS |>
    getSampleSizeSurvival(
        median1 = 18,
        median2 = 12,
        dropoutRate1 = 0.05,
        dropoutRate2 = 0.05,
        dropoutTime = 12,
        accrualTime = c(0, 16), # not just 16 here!
        maxNumberOfSubjects = 400
    ) |>
    fetch(
        accrualIntensity,
        followUpTime,
        analysisTime
    )


## -----------------------------------------------------------------------------
#| echo: true
accrualTimetList <- list(
    "0 - <16" = 25
)

designGS |>
    getSampleSizeSurvival(
        median1 = 18,
        median2 = 12,
        dropoutRate1 = 0.05,
        dropoutRate2 = 0.05,
        dropoutTime = 12,
        accrualTime = accrualTimetList
    ) |>
    fetch(
        accrualIntensity,
        followUpTime,
        analysisTime
    )


## -----------------------------------------------------------------------------
#| echo: true
designGS |>
    getSampleSizeSurvival(
        hazardRatio = 2 / 3,
        median2 = 12,
        dropoutRate1 = 0.05,
        dropoutRate2 = 0.05,
        dropoutTime = 12,
        accrualTime = 0,
        accrualIntensity = 25,
        followUpTime = 12
    ) |>
    fetch(
        maxNumberOfSubjects,
        followUpTime,
        analysisTime
    )


## -----------------------------------------------------------------------------
#| echo: true
designGS |>
    getSampleSizeSurvival(
        median1 = 18,
        median2 = 12,
        dropoutRate1 = 0.05,
        dropoutRate2 = 0.05,
        dropoutTime = 12,
        accrualTime = c(0, 3, 6, 16),
        accrualIntensity = c(15, 20, 25)
    ) |>
    fetch(
        maxNumberOfSubjects,
        followUpTime,
        analysisTime
    )


## -----------------------------------------------------------------------------
#| echo: true
accrualTimetList <- list(
    "0 - < 3" = 15,
    "3 - < 6" = 20,
    "6 - <= 16" = 25
)

designGS |>
    getSampleSizeSurvival(
        median1 = 18,
        median2 = 12,
        dropoutRate1 = 0.05,
        dropoutRate2 = 0.05,
        dropoutTime = 12,
        accrualTime = accrualTimetList
    ) |>
    fetch(
        maxNumberOfSubjects,
        followUpTime,
        analysisTime
    )


## -----------------------------------------------------------------------------
setOutputFormat("accrualTime",
    digits = 0,
    nsmall = 0, roundFunction = "ceiling"
)


## -----------------------------------------------------------------------------
#| echo: true
accrualTimetList <- list(
    "0 - < 3" = 15,
    "3 - < 6" = 20,
    "6 - Inf" = 25
)

designGS |>
    getSampleSizeSurvival(
        median1 = 18,
        median2 = 12,
        dropoutRate1 = 0.05,
        dropoutRate2 = 0.05,
        dropoutTime = 12,
        accrualTime = accrualTimetList,
        maxNumberOfSubjects = 355
    ) |>
    fetch(
        accrualTime,
        followUpTime,
        analysisTime
    )


## -----------------------------------------------------------------------------
#| echo: true
designGS |>
    getSampleSizeSurvival(
        median1 = 18,
        median2 = 12,
        accrualTime = c(0, 3, 6),
        accrualIntensity = c(15, 20, 25),
        followUpTime = 12
    ) |>
    fetch(
        maxNumberOfSubjects,
        accrualTime,
        analysisTime
    )


## -----------------------------------------------------------------------------
#| echo: true
designGS |>
    getPowerSurvival(
        median1 = 18,
        median2 = 12,
        dropoutRate1 = 0.05,
        dropoutRate2 = 0.05,
        dropoutTime = 12,
        accrualTime = c(0, 3, 6, 16),
        accrualIntensity = c(15, 20, 25),
        maxNumberOfEvents = 257,
        directionUpper = FALSE # Important!
    ) |>
    fetch(analysisTime, overallReject)


## -----------------------------------------------------------------------------
#| echo: true
designGS |>
    getSimulationSurvival(
        median1 = 18,
        median2 = 12,
        dropoutRate1 = 0.05,
        dropoutRate2 = 0.05,
        dropoutTime = 12,
        maxNumberOfIterations = 10000,
        accrualTime = c(0, 3, 6, 16),
        accrualIntensity = c(15, 20, 25),
        plannedEvents = c(129, 257), # Note this different input here!
        directionUpper = FALSE,
        seed = 12345
    ) |>
    fetch(analysisTime, overallReject)


## -----------------------------------------------------------------------------
#| echo: true
designIN <- getDesignInverseNormal(
    kMax = 2,
    typeOfDesign = "asOF",
    beta = 0.1
)
designIN


## -----------------------------------------------------------------------------
#| echo: true
designIN |>
    getPowerSurvival(
        median1 = 18,
        median2 = 12,
        accrualTime = c(0, 16),
        maxNumberOfSubjects = 2000,
        maxNumberOfEvents = 257,
        directionUpper = FALSE,
        dropoutRate1 = 0.05,
        dropoutRate2 = 0.05,
        dropoutTime = 12
    ) |>
    fetch(analysisTime, overallReject)


## -----------------------------------------------------------------------------
#| echo: true
designIN |>
    getSimulationSurvival(
        median1 = 18,
        median2 = 12,
        maxNumberOfIterations = 10000,
        accrualTime = c(0, 16),
        maxNumberOfSubjects = 2000,
        plannedEvents = c(129, 257),
        directionUpper = FALSE,
        dropoutRate1 = 0.05,
        dropoutRate2 = 0.05,
        dropoutTime = 12,
        conditionalPower = 0.9,
        # no sample size reduction is allowed:
        minNumberOfEventsPerStage = c(NA, 128),
        # up to 10-fold increase:
        maxNumberOfEventsPerStage = 10 * c(NA, 128),
        seed = 23456
    ) |>
    fetch(analysisTime, overallReject)


## -----------------------------------------------------------------------------
#| echo: true
designIN <- getDesignInverseNormal(
    kMax = 2,
    typeOfDesign = "asOF"
)
designIN |>
    getSimulationSurvival(
        hazardRatio = 1,
        maxNumberOfIterations = 10000,
        accrualTime = c(0, 16),
        maxNumberOfSubjects = 2000,
        plannedEvents = c(129, 257),
        directionUpper = FALSE,
        dropoutRate1 = 0.05,
        dropoutRate2 = 0.05,
        dropoutTime = 12,
        conditionalPower = 0.9,
        minNumberOfEventsPerStage = c(NA, 128),
        maxNumberOfEventsPerStage = 10 * c(NA, 128),
        seed = 34567
    ) |>
    fetch(overallReject)

designGS |>
    getSimulationSurvival(
        hazardRatio = 1,
        maxNumberOfIterations = 10000,
        accrualTime = c(0, 16),
        maxNumberOfSubjects = 2000,
        plannedEvents = c(129, 257),
        directionUpper = FALSE,
        dropoutRate1 = 0.05,
        dropoutRate2 = 0.05,
        dropoutTime = 12,
        conditionalPower = 0.9,
        minNumberOfEventsPerStage = c(NA, 128),
        maxNumberOfEventsPerStage = 10 * c(NA, 128),
        seed = 45678
    ) |>
    fetch(overallReject)


## -----------------------------------------------------------------------------
#| echo: true
#| eval: true
designIN |> getSimulationSurvival(
    median1 = c(18, 12),
    median2 = 12,
    maxNumberOfIterations = 10000,
    accrualTime = c(0, 16),
    maxNumberOfSubjects = 2000,
    plannedEvents = c(129, 257),
    directionUpper = FALSE,
    conditionalPower = 0.9,
    dropoutRate1 = 0.05,
    dropoutRate2 = 0.05,
    dropoutTime = 12,
    minNumberOfEventsPerStage = c(NA, 128),
    maxNumberOfEventsPerStage = 10 * c(NA, 128),
    seed = 56789
)


## -----------------------------------------------------------------------------
#| echo: true
eventsMax <- 350 # could be further decreased
designIN |>
    getSimulationSurvival(
        piecewiseSurvivalTime = c(0, 6), # new!
        lambda1 = c(log(2) / 12, log(2) / 18), # delay!
        lambda2 = rep(log(2) / 12, 2),
        maxNumberOfIterations = 10000,
        accrualTime = c(0, 16),
        maxNumberOfSubjects = 2000,
        plannedEvents = c(0.6 * eventsMax, eventsMax), # Increased
        directionUpper = FALSE,
        dropoutRate1 = 0.05,
        dropoutRate2 = 0.05,
        dropoutTime = 12,
        conditionalPower = 0.9,
        minNumberOfEventsPerStage = c(NA, 128),
        maxNumberOfEventsPerStage = 10 * c(NA, 128),
        seed = 56789
    ) |>
    fetch(overallReject)


## -----------------------------------------------------------------------------
#| echo: true
getDesignInverseNormal(
    kMax = 2,
    typeOfDesign = "asOF",
    beta = 0.1,
    informationRates = c(0.5, 1),
    futilityBounds = 0.5,
    futilityBoundsScale = "condPowerAtObserved"
)


## -----------------------------------------------------------------------------
#| echo: true
scenarios <- list(
    list(futilityBounds = 0.6, infRate = 0.6),
    list(futilityBounds = 0.5, infRate = 0.5),
    list(futilityBounds = 0.4, infRate = 0.4),
    list(futilityBounds = 0.3, infRate = 0.4),
    list(futilityBounds = 0.2, infRate = 0.4)
)


## -----------------------------------------------------------------------------
#| echo: true
results <- scenarios |>
    lapply(function(scenario) {
        getDesignInverseNormal(
            kMax = 2,
            typeOfDesign = "asOF",
            beta = 0.1,
            informationRates = c(scenario$infRate, 1),
            futilityBounds = scenario$futilityBounds,
            futilityBoundsScale = "condPowerAtObserved"
        ) |> getSampleSizeSurvival(
            median1 = 18,
            median2 = 12,
            dropoutRate1 = 0.05,
            dropoutRate2 = 0.05,
            dropoutTime = 12,
            accrualTime = c(0, 16),
            maxNumberOfSubjects = 1000
        )
    })


## -----------------------------------------------------------------------------
#| echo: true
sapply(results, function(result) {
    result |>
        fetch(
            "Maximal study duration",
            "Futility bounds (treatment effect scale)",
            "Expected number of subjects under H1"
        )
})