如何计算事件总持续时间的经过时间？

Question

I have collected a dataframe that models the duration of time for events in a group problem solving session in which the members Communicate ( Discourse Code ) and construct models ( Modeling Code ). Each minute that that occurs is captured in the Time_Processed column. Technically these events occur simultaneously. I would like to know how long the students are constructing each type of model which is the total duration of that model or the time elapsed before that model changes.

I have the following dataset:

Looks like this:

 `Modeling Code` `Discourse Code` Time_Processed
   <fct>           <fct>                     <dbl>
 1 OFF             OFF                        10.0
 2 MA              Q                          11.0
 3 MA              AG                         16.0
 4 V               S                          18.0
 5 V               Q                          20.0
 6 MA              C                          21.0
 7 MA              C                          23.0
 8 MA              C                          25.0
 9 V               J                          26.0
10 P               S                          28.0

# My explicit dataframe. 
df <- structure(list(`Modeling Code` = structure(c(3L, 2L, 2L, 6L, 
6L, 2L, 2L, 2L, 6L, 4L), .Label = c("A", "MA", "OFF", "P", "SM", 
"V"), class = "factor"), `Discourse Code` = structure(c(7L, 8L, 
1L, 9L, 8L, 2L, 2L, 2L, 6L, 9L), .Label = c("AG", "C", "D", "DA", 
"G", "J", "OFF", "Q", "S"), class = "factor"), Time_Processed = c(10, 
11, 16, 18, 20, 21, 23, 25, 26, 28)), row.names = c(NA, -10L), .Names = c("Modeling Code", 
"Discourse Code", "Time_Processed"), class = c("tbl_df", "tbl", 
"data.frame"))

For this dataframe I can find how often the students were constructing each type of model logically like this.

With Respect to the Modeling Code and Time_Processed columns,

At 10 minutes they are using the OFF model method, then at 11 minutes, they change the model so the duration of the OFF model is (11 - 10) minutes = 1 minute. There are no other occurrences of the "OFF" method so the duration of OFF = 1 min .

Likewise, for Modeling Code method "MA", the model is used from 11 minutes to 16 minutes (duration = 5 minutes) and then from 16 minutes to 18 minutes before the model changes to V with (duration = 2 minutes), then the model is used again at 21 minutes and ends at 26 minutes (duration = 5 minutes). So the total duration of "MA" is (5 + 2 + 5) minutes = 12 minutes .

Likewise the duration of Modeling Code method "V" starts at 18 minutes, ends at 21 minutes (duration = 3 minutes), resumes at 26 minutes, ends at 28 minutes (duration = 2) minutes. So total duration of "V" is 3 + 2 = 5 minutes .

Then the duration of Modeling Code P, starts at 28 minutes and there is no continuity so total duration of P is 0 minutes .

So the total duration (minutes) table of the Modeling Codes is this:

Modeling Code     Total_Duration
    OFF               1
    MA               12
    V                 5 
    P                 0 

This models a barchart that looks like this:

How can the total duration of these modeling methods be constructed?

It would also be nice to know the duration of the combinations such that the only visible combination in this small subset happens to be Modeling Code "MA" paired with Discourse Code "C" and this occurs for 26 - 21 = 5 minutes.

Thank you.

Answer 1

UPDATED SOLUTION

df %>% 
  mutate(dur = lead(Time_Processed) - Time_Processed) %>% 
  replace_na(list(dur = 0)) %>% 
  group_by(`Modeling Code`) %>% 
  summarise(tot_time = sum(dur))

(^ Thanks to Nick DiQuattro )

PREVIOUS SOLUTION
Here's one solution that creates a new variable, mcode_grp , which keeps track of discrete groupings of the same Modeling Code . It's not particularly pretty - it requires looping over each row in df - but it works.

First, rename columns for ease of reference:

df <- df %>%
  rename(m_code = `Modeling Code`,
         d_code = `Discourse Code`)

We'll update df with a few extra variables.
- lead_time_proc gives us the Time_Processed value for the next row in df , which we'll need when computing the total amount of time for each m_code batch
- row_n for keeping track of row number in our iteration
- mcode_grp is the unique label for each m_code batch

df <- df %>%
  mutate(lead_time_proc = lead(Time_Processed),
         row_n = row_number(),
         mcode_grp = "") 

Next, we need a way to keep track of when we've hit a new batch of a given m_code value. One way is to keep a counter for each m_code , and increment it whenever a new batch is reached. Then we can label all the rows for that m_code batch as belonging to the same time window.

mcode_ct <- df %>% 
  group_by(m_code) %>% 
  summarise(ct = 0) %>%
  mutate(m_code = as.character(m_code))

This is the ugliest part. We loop over every row in df , and check to see if we've reached a new m_code . If so, we update accordingly, and register a value for mcode_grp for each row.

mc <- ""
for (i in 1:nrow(df)) {
  current_mc <- df$m_code[i]
  if (current_mc != mc) {
    mc <- current_mc
    mcode_ct <- mcode_ct %>% mutate(ct = ifelse(m_code == mc, ct + 1, ct))
    current_grp <- mcode_ct %>% filter(m_code == mc) %>% select(ct) %>% pull()
  }
  df <- df %>% mutate(mcode_grp = ifelse(row_n == i, current_grp, mcode_grp))
}

Finally, group_by m_code and mcode_grp , compute the duration for each batch, and then sum over m_code values.

 df %>%
   group_by(m_code, mcode_grp) %>%
   summarise(start_time = min(Time_Processed),
             end_time = max(lead_time_proc)) %>%
   mutate(total_time = end_time - start_time) %>%
   group_by(m_code) %>%
   summarise(total_time = sum(total_time)) %>%
   replace_na(list(total_time=0))

Output:

# A tibble: 4 x 2
  m_code total_time
  <fct>       <dbl>
1 MA            12.
2 OFF            1.
3 P              0.
4 V              5.

For any dplyr / tidyverse experts out there, I'd love tips on how to accomplish more of this without resorting to loops and counters!