# TCGA_Data_Preparation.R

getGDCprojects()

# Download_GDC.R

# ==== Preperation ====
if (!require(SummarizedExperiment)) {
  install.packages("SummarizedExperiment")
  library(SummarizedExperiment)
}
if (!require(parallel)) {
  install.packages("parallel")
  library(parallel)
}
if (!require(data.table)) {
  install.packages("data.table")
  library(data.table)
}
# Note that on Linux, libmariadb-client-lgpl-dev must be installed
# This allows for configuration of RMySQL
if (!require(TCGAbiolinks)) {
  if (!requireNamespace("BiocManager", quietly = TRUE))
    install.packages("BiocManager")
  BiocManager::install("TCGAbiolinks")
  require(TCGAbiolinks)
  ??TCGAbiolinks
  
  library(TCGAbiolinks)
}

getGDCInfo()
getGDCprojects()
getProjectSummary("TCGA-ACC")
# Data Release 28, February 02, 2021
# Move all data to a single directory later on
dir.create(("Data/TCGA"))
dir.create("Data/TCGA/SummarizedExperiments")
dir.create("Data/TCGA/SummarizedExperiments/Mut")
dir.create("Data/TCGA/SummarizedExperiments/CNV")
dir.create("Data/TCGA/SummarizedExperiments/Exp")

projects <- TCGAbiolinks:::getGDCprojects()$project_id
projects <- projects[grepl('^TCGA', projects, perl=TRUE)]


# ==== Download Mut data ====
plyr::alply(sort(projects), 1, function(cur_project) {
  tryCatch(
    query <- GDCquery(
      project = cur_project,
      data.category = "Simple Nucleotide Variation",
      data.type = "Masked Somatic Mutation",
      workflow.type = 'VarScan2 Variant Aggregation and Masking'
    )
  )
  query <- GDCquery(
    project = cur_project,
    data.category = "Simple Nucleotide Variation",
    data.type = "Masked Somatic Mutation",
    workflow.type = 'VarScan2 Variant Aggregation and Masking'
  )
  
  GDCdownload(query, files.per.chunk = 10, method = "client")
  GDCprepare(query,
    save = T,
    save.filename = paste0("Data/TCGA/SummarizedExperiments/Mut/", cur_project,
                           "_VarScan2_MAF.rdata")
  )
})

# ==== Download CNV data ====
plyr::alply(sort(projects)[-(1:14)], 1, function(cur_project) {
  tryCatch(
    query <- GDCquery(
      project = cur_project,
      data.category = "Copy Number Variation",
      data.type = "Masked Copy Number Segment", 
    )
  )
  query <- GDCquery(
    project = cur_project,
    data.category = "Copy Number Variation",
    data.type = "Masked Copy Number Segment",
  )
  GDCdownload(query, files.per.chunk = 10)
  GDCprepare(query,
             save = T,
             save.filename = paste0("Data/TCGA/SummarizedExperiments/CNV/", cur_project,
                                    "_CopyNumber.rdata"))
  # cur_proj_data <- get(load(paste0("Data/TCGA/SummarizedExperiments/CNV/", cur_project, "_CopyNumber.rdata")))
  
})

# ==== Download clinical CNV data ====

dir.create("Data/TCGA/Clinical")
dir.create("Data/TCGA/Clinical/CNV")
plyr::alply(sort(projects)[-(1:14)], 1, function(cur_project) {
  tryCatch(
    query.biospecimen <- GDCquery(project = cur_project, 
                                  data.category = "Biospecimen",
                                  data.type = "Biospecimen Supplement", 
                                  data.format = "BCR Biotab")
  )
  query.biospecimen <- GDCquery(project = cur_project, 
                                data.category = "Biospecimen",
                                data.type = "Biospecimen Supplement", 
                                data.format = "BCR Biotab")
  GDCdownload(query.biospecimen, files.per.chunk = 10)
  GDCprepare(query.biospecimen,
             save = T,
             save.filename = paste0("Data/TCGA/Clinical/CNV/", cur_project,
                                    "_CopyNumber_Clinical.rdata"))
  
})

# ==== Download gene expression data ====
plyr::alply(projects, 1, function(cur_project) {
  tryCatch(
      query <- GDCquery(
          project = cur_project,
          data.category = "Transcriptome Profiling",
          data.type = "Gene Expression Quantification",
          workflow.type = "HTSeq - Counts"
      )
  )
  query <- GDCquery(
    project = cur_project,
    data.category = "Transcriptome Profiling",
    data.type = "Gene Expression Quantification",
    workflow.type = "HTSeq - Counts"
  )
  GDCdownload(query, files.per.chunk = 10, method = "client")
  GDCprepare(
    query,
    save = T,
    save.filename = paste0("Data/TCGA/SummarizedExperiments/Exp/", cur_project, "_GeneExpression.rdata")
  )
  
})


# =====================================
# For each data type, combine all projects into a single file
require(data.table)
require(TCGAbiolinks)
require(SummarizedExperiment)
require(GeoTcgaData)
require(stringr)
require(biomaRt)
require(curl)

# Get clinical info from Gene Expression data ====
all_proj_info <- vector(mode = "list", length = length(projects))
i <- 1
for (cur_project in projects) {
  cur_proj_data <- get(load(paste0("Data/TCGA/SummarizedExperiments/Exp/", cur_project, "_GeneExpression.rdata")))
  cur_proj_assay <- assays(cur_proj_data)[[1]]
  cur_proj_info <- colData(cur_proj_data)
  all_proj_info[[i]] <- as.data.table(cur_proj_info[, c("barcode", "name")])
  i <- i + 1
}

all_proj_info <- rbindlist(all_proj_info)
# Save
fwrite(all_proj_info, "Data/TCGA/All_Sample_Info.csv")


# ==== Merge Exp Data ====
require(data.table)
require(biomaRt)
dir.create("Data/TCGA/Exp")
projects <- TCGAbiolinks:::getGDCprojects()$project_id
projects <- projects[grepl('^TCGA', projects, perl=TRUE)]
# gene_dict <- fread("Data/gene_dictionary.txt")
depmap_exp <- fread("Data/DepMap/20Q2/CCLE_expression.csv")
depmap_ensg_numbers <- str_replace(colnames(depmap_exp), ".+\\((.+)\\)", "\\1")
depmap_hgnc <- str_replace(colnames(depmap_exp), "(.+)\\s\\(.+\\)", "\\1")
depmap_exp_dict <- data.table(HGNC = depmap_hgnc, ENSG = depmap_ensg_numbers)

rm(depmap_exp)

ensembl = useMart(
  biomart = "ENSEMBL_MART_ENSEMBL",
  # host = "feb2014.archive.ensembl.org",
  path = "/biomart/martservice",
  dataset = "hsapiens_gene_ensembl"
)
atts <- listAttributes(ensembl, what = "name")
atts[grep(pattern = "gene", x = atts, ignore.case = T)]

cur_project = projects[1]

for (cur_project in projects) {
  cur_proj_data <- get(load(paste0("Data/TCGA/SummarizedExperiments/Exp/", cur_project, "_GeneExpression.rdata")))
  cur_proj_assay <- assays(cur_proj_data)[[1]]
  cur_proj_info <- colData(cur_proj_data)
  cur_proj_tpm <- GeoTcgaData::fpkmToTpm_matrix(cur_proj_assay)
  
  # log2 transform with a pseudo-count of 1
  cur_proj_tpm <- cur_proj_tpm+1
  cur_proj_tpm <- log2(cur_proj_tpm)
  
  # Convert ENSG ID's to numbers
  cur_ensg_numbers <- str_replace(rownames(cur_proj_tpm), "ENSG0*", "")
  cur_proj_tpm_dt <- as.data.table(cur_proj_tpm, keep.rownames = T)
  cur_dict <- biomaRt::getBM(attributes = c("ensembl_gene_id",
                                            "external_gene_name"),
                         filters = "ensembl_gene_id", values = cur_proj_tpm_dt$rn,
                         mart = ensembl)
  cur_dict <- as.data.table(cur_dict)
  temp <- merge(cur_proj_tpm_dt, cur_dict, by.x = "rn", by.y = "ensembl_gene_id")
  # Find overlap with HGNC symbols in DepMap 
  cur_reduced_dt <- temp[external_gene_name %in% depmap_exp_dict$HGNC]
  
  dup_genes <- cur_reduced_dt[duplicated(cur_reduced_dt$external_gene_name)]$external_gene_name
  # Duplicated genes may represent transcripts from the same gene, must consolidate by adding TPM values
  cur_reduced_dt$rn <- NULL
  cur_reduced_dt <- cur_reduced_dt[, lapply(.SD, sum), by = external_gene_name]
  final_dt <- transpose(cur_reduced_dt, keep.names = "external_gene_name")
  
  colnames(final_dt) <- unname(unlist(final_dt[1,]))
  final_dt <- final_dt[!(TSPAN6 == "TSPAN6")]
  # Add cancer type
  final_dt <- cbind(cancer_type = cur_proj_info$name, final_dt)
  colnames(final_dt)[2] <- "tcga_sample_id"
  # Sort all the other columns
  new_order <- c("tcga_sample_id", "cancer_type", sort(colnames(final_dt)[-c(1:2)]))
  setcolorder(final_dt, new_order)
  
  fwrite(final_dt, paste0("Data/TCGA/Exp/", cur_project, "_Exp.csv"))
}

# Now merge all the data.tables
exp_file_paths <- list.files("Data/TCGA/Exp/", full.names = T)
exp_dt_list <- vector(mode = "list", length = length(exp_file_paths))

for (i in 1:length(exp_file_paths)) {
  exp_dt_list[[i]] <- fread(exp_file_paths[i])
}

all_exp <- rbindlist(exp_dt_list)
all_exp[1:5, 1:5]
dim(all_exp)
fwrite(all_exp, "Data/TCGA/TCGA_All_Exp_Data.csv")
rm(exp_dt_list)
rm(all_exp)

# all_exp <- fread("Data/TCGA/TCGA_All_Exp_Data.csv")
# ==== Merge CNV Data ====
require(GenomicRanges)
# Must find the genomic ranges of genes in DepMap CNV data (ensure reference is the same), then merge using the GRanges package (map onto)
dir.create("Data/TCGA/CNV")
projects <- TCGAbiolinks:::getGDCprojects()$project_id
projects <- projects[grepl('^TCGA', projects, perl=TRUE)]
# gene_dict <- fread("Data/gene_dictionary.txt")
depmap_cnv <- fread("Data/DepMap/20Q2/CCLE_gene_copy_number.csv")
head(colnames(depmap_cnv))
depmap_ensg_numbers <- str_replace(colnames(depmap_cnv), ".+\\((.+)\\)", "\\1")
depmap_hgnc <- str_replace(colnames(depmap_cnv), "(.+)\\s\\(.+\\)", "\\1")
depmap_cnv_dict <- data.table(HGNC = depmap_hgnc, ENSG = depmap_ensg_numbers)

rm(depmap_cnv)

ensembl = useMart(
  biomart = "ENSEMBL_MART_ENSEMBL",
  # host = "feb2014.archive.ensembl.org",
  path = "/biomart/martservice",
  dataset = "hsapiens_gene_ensembl"
)

cur_translation <- biomaRt::getBM(attributes = c("ensembl_gene_id", "wikigene_name",
                                                 "external_gene_name", 'chromosome_name',
                                                 'start_position', 'end_position', 'strand'),
                           filters = "external_gene_name", values = depmap_cnv_dict$HGNC, uniqueRows = T,
                           mart = ensembl)
cur_translation <- as.data.table(cur_translation)
cur_translation <- cur_translation[!duplicated(cur_translation[,"wikigene_name"]), ]
cur_translation <- cur_translation[!duplicated(cur_translation[,"external_gene_name"]), ]

depmap_cnv_dict_1 <- merge(depmap_cnv_dict, cur_translation, by.x = "HGNC", by.y = "external_gene_name")
depmap_cnv_dict_1$wikigene_name <- NULL
# unfound <- depmap_cnv_dict$HGNC[!(depmap_cnv_dict$HGNC %in% cur_translation$wikigene_name)]
unfound <- depmap_cnv_dict$HGNC[!(depmap_cnv_dict$HGNC %in% cur_translation$external_gene_name)]
# Search for the unfound in wikigene info
unfound_translation <- biomaRt::getBM(attributes = c("ensembl_gene_id", "wikigene_name",
                                                 "external_gene_name", 'chromosome_name',
                                                 'start_position', 'end_position', 'strand'),
                                  filters = "wikigene_name", values = unfound, uniqueRows = T,
                                  mart = ensembl)
unfound_translation <- as.data.table(unfound_translation)
depmap_cnv_dict_2 <- merge(depmap_cnv_dict, unfound_translation, by.x = "HGNC", by.y = "wikigene_name")
depmap_cnv_dict_2$external_gene_name <- NULL

# Add together
# all_translation <- rbindlist(list(cur_translation, unfound_translation))
depmap_cnv_dict <- rbindlist(list(depmap_cnv_dict_1, depmap_cnv_dict_2))
depmap_cnv_dict$strand[depmap_cnv_dict$strand == -1] <- "-"
depmap_cnv_dict$strand[depmap_cnv_dict$strand == 1] <- "+"

# Convert to GRanges
depmap_cnv_granges <- makeGRangesFromDataFrame(df = depmap_cnv_dict, keep.extra.columns = T, seqnames.field = "chromosome_name",
                         start.field = "start_position", end.field = "end_position", strand.field = "strand")

atts <- listAttributes(ensembl, what = "name")
atts[grep(pattern = "gene", x = atts, ignore.case = T)]
atts[grep(pattern = "chromosome", x = atts, ignore.case = T)]

cur_project = projects[1]

rm(list = c("depmap_cnv_dict_1", "depmap_cnv_dict_2"))


for (cur_project in projects) {
  cur_proj_data <- get(load(paste0("Data/TCGA/SummarizedExperiments/CNV/", cur_project, "_CopyNumber.rdata")))
  # Convert to GRanges
  cur_proj_granges <- makeGRangesFromDataFrame(df = cur_proj_data, keep.extra.columns = T, start.field = "Start",
                                               end.field = "End", seqnames.field = "Chromosome")
  # Merge with DepMap data
  cur_proj_merge <- mergeByOverlaps(query = cur_proj_granges, subject = depmap_cnv_granges)
  cur_proj_merge <- cur_proj_merge[, c("Sample", "HGNC", "Segment_Mean")]
  cur_proj_merge <- as.data.table(cur_proj_merge)
  cur_proj_merge <- unique(cur_proj_merge)
  
  cur_wide_data <- dcast(cur_proj_merge, Sample ~ HGNC, value.var = "Segment_Mean", fun.aggregate = sum)
  
  colnames(cur_wide_data)[1] <- "tcga_sample_id"
  # Sort all the other columns
  new_order <- c("tcga_sample_id", sort(colnames(cur_wide_data)[-1]))
  setcolorder(cur_wide_data, new_order)

  fwrite(cur_wide_data, paste0("Data/TCGA/CNV/", cur_project, "_CNV.csv"))
}

# Now merge all the data.tables
cnv_file_paths <- list.files("Data/TCGA/CNV/", full.names = T)
cnv_dt_list <- vector(mode = "list", length = length(cnv_file_paths))

for (i in 1:length(cnv_file_paths)) {
  cnv_dt_list[[i]] <- fread(cnv_file_paths[i])
}

all_cnv <- rbindlist(cnv_dt_list)
all_cnv[1:5, 1:5]
fwrite(all_cnv, "Data/TCGA/TCGA_All_CNV_Data.csv")

# The first 3 ID's should be enough to indicate tumor type
require(stringr)
all_proj_info <- fread("Data/TCGA/All_Sample_Info.csv")
temp <- str_split_fixed(all_proj_info$barcode, "-", n = 7)[, 1:3]
all_proj_info$sub_id <- paste(temp[,1], temp[,2], temp[,3], sep = '-')

all_cnv <- fread("Data/TCGA/TCGA_All_CNV_Data.csv")
temp2 <- str_split_fixed(all_cnv$tcga_sample_id, "-", n = 7)[, 1:4]
sample_type <- str_split_fixed(temp2[, 4], "", n=3)[, 1:2]
sample_type <- as.integer(paste0(sample_type[,1], sample_type[,2]))
all_cnv$sub_id <- paste(temp2[,1], temp2[,2], temp2[,3], sep = '-')

all_cnv$sample_type <- ifelse(sample_type < 10, yes = "Tumor", no = "Normal")
table(all_cnv$sample_type)

# Subset to Tumor
all_cnv <- all_cnv[sample_type == "Tumor"]
# add cancer type
all_cnv <- merge(all_cnv, all_proj_info[, c("name", "sub_id")], by = "sub_id")
table(all_cnv$name)
dim(all_cnv)
# remove sub_id, sample_type
all_cnv$sub_id <- NULL
all_cnv$sample_type <- NULL
# reorder
setcolorder(all_cnv, "name")
colnames(all_cnv)[1] <- "cancer_type"
all_cnv[1:5, 1:5]

# Save
fwrite(all_cnv, "Data/TCGA/TCGA_All_CNV_Data.csv")

dim(all_cnv)

rm(cnv_dt_list)
rm(all_cnv)


# ==== Merge Mut Data ====
# dir.create("Data/TCGA/Mut")
# projects <- TCGAbiolinks:::getGDCprojects()$project_id
# projects <- projects[grepl('^TCGA', projects, perl=TRUE)]
# # gene_dict <- fread("Data/gene_dictionary.txt")
# depmap_mut <- fread("Data/DRP_Training_Data/DepMap_20Q2_CGC_Mutations_by_Cell.csv")
# depmap_ensg_numbers <- str_replace(colnames(depmap_mut), ".+\\((.+)\\)", "\\1")
# depmap_hgnc <- str_replace(colnames(depmap_mut), "(.+)\\s\\(.+\\)", "\\1")
# depmap_mut_dict <- data.table(HGNC = depmap_hgnc, ENSG = depmap_ensg_numbers)
# 
# rm(depmap_mut)
# 
# ensembl = useMart(
#   biomart = "ENSEMBL_MART_ENSEMBL",
#   # host = "feb2014.archive.ensembl.org",
#   path = "/biomart/martservice",
#   dataset = "hsapiens_gene_ensembl"
# )
# atts <- listAttributes(ensembl, what = "name")
# 
# # cur_project = projects[1]
# 
# for (cur_project in projects) {
#   cur_proj_data <- get(load(paste0("Data/TCGA/SummarizedExperiments/Mut/", cur_project, "_VarScan2_MAF.rdata")))
#   cur_sub <- cur_proj_data[, c("Hugo_Symbol", "Variant_Classification", "Variant_Type", "Tumor_Sample_Barcode")]
#   unique(cur_sub$Hugo_Symbol)
#   # Find overlap with DepMap
#   sum(depmap_mut_dict$HGNC %in% unique(cur_sub$Hugo_Symbol))
#   
#   
#   cur_proj_assay <- assays(cur_proj_data)[[1]]
#   # cur_proj_assay[1:5, 1:5]
#   # class(cur_proj_assay)
#   cur_proj_tpm <- GeoTcgaData::fpkmToTpm_matrix(cur_proj_assay)
#   # Convert ENSG ID's to numbers
#   cur_ensg_numbers <- str_replace(rownames(cur_proj_tpm), "ENSG0*", "")
#   cur_proj_tpm_dt <- as.data.table(cur_proj_tpm, keep.rownames = T)
#   # cur_proj_tpm_dt[1:5, 1:5]
#   # cur_proj_tpm_dt$rn <- str_replace(cur_proj_tpm_dt$rn, "ENSG0*", "")
#   cur_dict <- biomaRt::getBM(attributes = c("ensembl_gene_id",
#                                             "external_gene_name"),
#                              filters = "ensembl_gene_id", values = cur_proj_tpm_dt$rn,
#                              mart = ensembl)
#   cur_dict <- as.data.table(cur_dict)
#   temp <- merge(cur_proj_tpm_dt, cur_dict, by.x = "rn", by.y = "ensembl_gene_id")
#   # dim(temp)
#   # Find overlap with HGNC symbols in DepMap 
#   cur_reduced_dt <- temp[external_gene_name %in% depmap_exp_dict$HGNC]
#   # dim(cur_reduced_dt)
#   
#   # sum(duplicated(cur_reduced_dt$external_gene_name))
#   dup_genes <- cur_reduced_dt[duplicated(cur_reduced_dt$external_gene_name)]$external_gene_name
#   # Duplicated genes may represent transcripts from the same gene, must consolidate by adding TPM values
#   cur_reduced_dt$rn <- NULL
#   cur_reduced_dt <- cur_reduced_dt[, lapply(.SD, sum), by = external_gene_name]
#   final_dt <- transpose(cur_reduced_dt, keep.names = "external_gene_name")
#   colnames(final_dt) <- unname(unlist(final_dt[1,]))
#   # final_dt[1:5, 1:5]
#   final_dt <- final_dt[!(TSPAN6 == "TSPAN6")]
#   # final_dt[1:5, 1:5]
#   # dim(final_dt)
#   
#   # temp1[external_gene_name %in% dup_genes][,c("external_gene_name", "TCGA-FI-A2D5-01A-11R-A17B-07")]
#   fwrite(final_dt, paste0("Data/TCGA/Exp/", cur_project, "_Exp.csv"))
# }
# 
# # Now merge all the data.tables
# exp_file_paths <- list.files("Data/TCGA/Exp/", full.names = T)
# exp_dt_list <- vector(mode = "list", length = length(exp_file_paths))
# 
# for (i in 1:length(exp_file_paths)) {
#   exp_dt_list[[i]] <- fread(exp_file_paths[i])
# }
# 
# all_exp <- rbindlist(exp_dt_list)
# fwrite(all_exp, "Data/TCGA/TCGA_All_Exp_Data.csv")
# 


# ==== Sort and Clean Data ====

# ==== Match TCGA and DepMap Exp Data ====
require(data.table)
exp_tcga <- fread("Data/TCGA/TCGA_All_Exp_Data.csv")
exp_tcga[1:5, 1:5]
exp_depmap <- fread("Data/DRP_Training_Data/DepMap_21Q2_Expression.csv")
exp_depmap[1:5, 1:5]
dim(exp_tcga)
dim(exp_depmap)

# Find shared columns:
shared_exp <- intersect(colnames(exp_depmap), colnames(exp_tcga))
# Sort columns
shared_exp <- sort(shared_exp)
shared_exp <- c("tcga_sample_id", "cancer_type", shared_exp)
exp_tcga <- exp_tcga[, ..shared_exp]
colnames(exp_tcga)[2] <- "primary_disease"

exp_tcga[1:5, 1:5]
dim(exp_tcga)

# Save TCGA pre-training data
fwrite(exp_tcga, "Data/DRP_Training_Data/TCGA_PreTraining_Expression.csv")

# Subset DepMap data to what's available in TCGA
shared_exp <- unique(c("stripped_cell_line_name", "primary_disease", sort(intersect(colnames(exp_depmap), colnames(exp_tcga)))))
exp_depmap <- exp_depmap[, ..shared_exp]
exp_depmap[1:5, 1:5]
dim(exp_depmap)
# Save DepMap training data
fwrite(exp_depmap, "Data/DRP_Training_Data/DepMap_21Q2_Training_Expression.csv")

rm(exp_depmap)
rm(exp_tcga)
# exp_tcga <- fread("Data/DRP_Training_Data/TCGA_PreTraining_Expression.csv")
# exp_depmap <- fread("Data/DRP_Training_Data/DepMap_20Q2_Training_Expression.csv")
# exp_tcga[1:5, 1:5]
# exp_depmap[1:5, 1:5]

# ==== Match TCGA and DepMap CNV Data ====
cnv_tcga <- fread("Data/TCGA/TCGA_All_CNV_Data.csv")
cnv_tcga[1:5, 1:5]
cnv_depmap <- fread("Data/DRP_Training_Data/DepMap_21Q2_CopyNumber.csv")
cnv_depmap[1:5, 1:5]
dim(cnv_depmap)
dim(cnv_tcga)

shared_cnv <- intersect(colnames(cnv_depmap), colnames(cnv_tcga))
# Sort columns
shared_cnv <- sort(shared_cnv)
shared_cnv <- c("tcga_sample_id", "cancer_type", shared_cnv)
cnv_tcga <- cnv_tcga[, ..shared_cnv]
colnames(cnv_tcga)[2] <- "primary_disease"

cnv_tcga[1:5, 1:5]

# Must add pseudocounts to log2 ratios of TCGA data
temp <- cnv_tcga[, -c(1:2)][, lapply(.SD, function(x) {log2(2**x + 1)})]
temp[1:5, 1:5]
temp$tcga_sample_id <- cnv_tcga$tcga_sample_id
temp$primary_disease <- cnv_tcga$primary_disease
setcolorder(temp, c("tcga_sample_id", "primary_disease"))
temp[1:5, 1:5]
dim(temp)

fwrite(temp, "Data/DRP_Training_Data/TCGA_PreTraining_CopyNumber.csv")


# Subset DepMap data to what's available in TCGA
cnv_depmap[1:5, 1:5]
shared_cnv <- unique(c("stripped_cell_line_name", "primary_disease", sort(intersect(colnames(cnv_depmap), colnames(cnv_tcga)))))
cnv_depmap <- cnv_depmap[, ..shared_cnv]

cnv_depmap[1:5, 1:5]
dim(cnv_depmap)
# Save DepMap training data
fwrite(cnv_depmap, "Data/DRP_Training_Data/DepMap_21Q2_Training_CopyNumber.csv")

rm(cnv_depmap)
rm(cnv_tcga)
gc()