BatchProcessing_2022_08_25_noncontinuousruns.m

%% Read in data from large LHS parameter sweep for TB-HIV-in-vitro model

%%% Note: I did my best to clean this script up so that it's valid for any
%%% batch run data with the .txt files set up the way I described.
%%% If encounter errors, I recommend first checking matrix size
%%% and making sure that is not the issue.

%%% This file should be run once before using data

%% Load files %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Location addresses of these .txt files will depend on your local
%%% computer.
% 

fileSinkPath ='/Users/apetruc/Downloads/Spring 2023/Paper 1/Paper stuff/Scaling2/Scaling2Compto1/100000/';

fileSinkDate ='.2023.Jul.17.12_16_03.';

dataTitle = 'ScalingData_2023_07_17_100000_3d.mat';

%%% AgentCounts is a .txt file that contains a header row with titles
%%% Each row in the file is one tick of one run, and the counts of each
%%% agent at that time.
agentCounts = strcat(fileSinkPath,'AgentCounts',fileSinkDate,'txt');
countTable = readtable(agentCounts);

%%% the BatchparamMap isa .txt file that contains a header with run and
%%% each parameter name. Each row corresponds to one run and the value of
%%% each parameter for that run.
agentCountsParam = strcat(fileSinkPath,'AgentCounts',fileSinkDate,'batch_param_map.txt');
paramsTable = readtable(agentCountsParam);

% MtbEvents is a .txt file that contains a header row with titles
% Each row in the file is one tick of one run, and the counts of each
% agent at that time.
mtbCounts = strcat(fileSinkPath,'MtbEvents',fileSinkDate,'txt');
countTableM = readtable(mtbCounts);

% Cd4Events is a .txt file that contains a header row with titles
% Each row in the file is one tick of one run, and the counts of each
% agent at that time.
cd4Counts = strcat(fileSinkPath,'CD4Events',fileSinkDate,'txt');
countTableC = readtable(cd4Counts);

% CD8Events is a .txt file that contains a header row with titles
% Each row in the file is one tick of one run, and the counts of each
% agent at that time.
cd8Counts = strcat(fileSinkPath,'CD8Events',fileSinkDate,'txt');
countTableCD8 = readtable(cd8Counts);

% ElapsedTime is a .txt file that contains a header row with titles
% Each row in the file is one tick of one run, and the counts of each
% agent at that time.
timeCounts = strcat(fileSinkPath,'ElapsedTime',fileSinkDate,'txt');
countTableE = readtable(timeCounts);

% MacrophageEvents is a .txt file that contains a header row with titles
% Each row in the file is one tick of one run, and the counts of each
% agent at that time.
macrophageEvents = strcat(fileSinkPath,'MacrophageEvents',fileSinkDate,'txt');
countTableMD = readtable(macrophageEvents);

% GranulomaStats is a .txt file that contains a header row with titles
% Each row in the file is one tick of one run, and the counts of each
% agent at that time.
% granulomaStats = strcat(fileSinkPath,'GranulomaStats',fileSinkDate,'txt');
% countTableG = readtable(granulomaStats);


%% Combine data %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% this section combines these data so that we can examine runs by what
% their parameters were. It takes a few minutes to do a large data set.
% Counts will show in the command window as each row and column is looped
ticks=max(countTable.tick);
runs=height(paramsTable);

%% Initialize outputs

% Agent Counts
totalMtbCount=NaN(ticks,runs);
totalCD4Count=NaN(ticks,runs);
tbSpecificCD4Count=NaN(ticks,runs);
activatedCD4Count=NaN(ticks,runs);
generatedCD4Count=NaN(ticks,runs);
nontbSpecificCD4Count=NaN(ticks,runs);
intracellularMtbCount=NaN(ticks,runs);
extracellularMtbCount=NaN(ticks,runs);
granulomaCount=NaN(ticks,runs);
totalMacroCount=NaN(ticks,runs);
infectedMacroCount=NaN(ticks,runs);
uninfectedMacroCount=NaN(ticks,runs);
activatedMacroCount=NaN(ticks,runs);
activatedInfectedMacroCount=NaN(ticks,runs);
activatedUninfectedMacroCount=NaN(ticks,runs);
totalStat1OnlyMacs=NaN(ticks,runs);
totalNfkbByCytoOnlyMacs=NaN(ticks,runs);
totalNfkbByMtbOnlyMacs=NaN(ticks,runs);
totalNfkbOnlyMacs=NaN(ticks,runs);
totalNfkbByMtbMacs=NaN(ticks,runs);
totalNfkbByCytoMacs=NaN(ticks,runs);
nfkbbyCytoofActivatedInfectedMacs=NaN(ticks,runs);
nfkbbyCytoofActivatedUninfectedMacs=NaN(ticks,runs);
nfkbByCytoOnlyInfMacs=NaN(ticks,runs);
nfkbByCytoOnlyUninfMacs=NaN(ticks,runs);
nfkbByMtbOnlyUninfMacs=NaN(ticks,runs);
nfkbByMtbOnlyInfMacs=NaN(ticks,runs);
nfkbbyMtbofActivatedInfectedMacs=NaN(ticks,runs);
nfkbbyMtbofActivatedUninfectedMacs=NaN(ticks,runs);
stat1OnlyInfMacs=NaN(ticks,runs);
stat1OnlyUninfMacs=NaN(ticks,runs);
totalChronicallyInfectedMacs=NaN(ticks,runs);
totalInfectedMacrophagesabovePhagocytosisThreshold=NaN(ticks,runs);
totalTBSpecificCD8s=NaN(ticks,runs);
totalActivatedCD8s=NaN(ticks,runs);
totalGeneratedCD8s=NaN(ticks,runs);
totalCD8=NaN(ticks,runs);
totalNfkbByMtbOfActivatedMacs=NaN(ticks,runs);
totalNfkbByCytoOfActivatedMacs=NaN(ticks,runs);
totalStat1MacroCount=NaN(ticks,runs);
totalNfkbMacroCount=NaN(ticks,runs);

% Mtb events
mtbResistantCount=NaN(ticks,runs);
mtbDivisionCount=NaN(ticks,runs);
mtbKilledCount=NaN(ticks,runs);
mtbKilledByActivatedMacCount=NaN(ticks,runs);
mtbKilledByRestingMacCount=NaN(ticks,runs);
mtbKilledByCD8Count=NaN(ticks,runs);

% CD4 events
failedToGenerateCount=NaN(ticks,runs);
activatedTBSpecificCD4DeathCount=NaN(ticks,runs);
restingTBSpecificCD4DeathCount=NaN(ticks,runs);
TBSpecificCD4DeathCount=NaN(ticks,runs);
nonTBSpecificCD4DeathCount=NaN(ticks,runs);
totalCD4DeathCount=NaN(ticks,runs);
CD4BecomesActivated=NaN(ticks,runs);
CD4ReachesMaxGenerations=NaN(ticks,runs);
CD4BecomesDeactivated=NaN(ticks,runs);

% CD8 events
CD8BecomesActivated=NaN(ticks,runs);
CD8BecomesDeactivated=NaN(ticks,runs);
CD8KillsBac=NaN(ticks,runs);
CD8KillsMac = NaN(ticks,runs);
CD8ReachesMaxGenerations=NaN(ticks,runs);
FailedToGenerateCD8Count=NaN(ticks,runs);
nonTBSpecificCD8DeathCount=NaN(ticks,runs);
activatedTBSpecificCD8DeathCount=NaN(ticks,runs);
restingTBSpecificCD8DeathCount=NaN(ticks,runs);
TBSpecificCD8DeathCount=NaN(ticks,runs);
totalCD8DeathCount=NaN(ticks,runs);

% Macrophage Events
ActivatedInfectedMacrophageDeathCountFromOldAge=NaN(ticks,runs);
RestingInfectedMacrophageDeathCountFromOldAge=NaN(ticks,runs);
TotalInfectedMacrophageDeathsFromOldAge=NaN(ticks,runs);
ActivatedUninfectedMacrophageDeathCountFromOldAge=NaN(ticks,runs);
RestingUninfectedMacrophageDeathCountFromOldAge=NaN(ticks,runs);
TotalUninfectedMacrophageDeathsFromOldAge=NaN(ticks,runs);
ActivatedMacrophageDeathCountFromBursting=NaN(ticks,runs);
RestingMacrophageDeathCountFromBursting=NaN(ticks,runs);
TotalMacrophageDeathCountFromBursting=NaN(ticks,runs);
TotalActivatedMacrophageDeathCountFromOldAge=NaN(ticks,runs);
TotalMacrophageDeathCountFromOldAge=NaN(ticks,runs);
TotalRestingMacrophageDeathCountFromOldAge=NaN(ticks,runs);
TotalMacrophageDeaths=NaN(ticks,runs);
MacrophageBecomesInfected=NaN(ticks,runs);
MacrophageBecomesUninfected=NaN(ticks,runs);
MacrophageInteractedWithMtbFirst=NaN(ticks,runs);
MacrophageInteractedWithMtbTotal=NaN(ticks,runs);
InfectedMacrosFightInfection=NaN(ticks,runs);
MacrophagePhagocytosesMtbUninfected=NaN(ticks,runs);
MacrophagePhagocytosesMtbInfected=NaN(ticks,runs);
MacrophagePhagocytosesMtbActivatedInfected=NaN(ticks,runs);
MacrophagePhagocytosesMtbBaseInfected=NaN(ticks,runs);
MacrophagePhagocytosesMtbActivatedUninfected=NaN(ticks,runs);
MacrophagePhagocytosesMtbBaseUninfected=NaN(ticks,runs);
MacrophageBecomesSTAT1Activated=NaN(ticks,runs);
MacrophageBecomesNFKBActivated=NaN(ticks,runs);
MacrophageBecomesNFKBActivatedByCyto=NaN(ticks,runs);
MacrophageBecomesNFKBActivatedByMtb=NaN(ticks,runs);
MacrophageBecomesTotallyActivated=NaN(ticks,runs);
MacrophageBecomesSTAT1Deactivated=NaN(ticks,runs);
MacrophageBecomesNFKBDeactivated=NaN(ticks,runs);
MacrophageBecomesNFKBByCytoDeactivated=NaN(ticks,runs);
MacrophageBecomesNFKBByMtbDeactivated=NaN(ticks,runs);
MacrophageBecomesDeactivated=NaN(ticks,runs);
MacrophageBecomesSTAT1ActivatedInfected=NaN(ticks,runs);
MacrophageBecomesNFKBActivatedInfected=NaN(ticks,runs);
MacrophageBecomesNFKBActivatedByCytoInfected=NaN(ticks,runs);
MacrophageBecomesNFKBActivatedByMtbInfected=NaN(ticks,runs);
MacrophageBecomesTotallyActivatedInfected=NaN(ticks,runs);
MacrophageBecomesSTAT1DeactivatedInfected=NaN(ticks,runs);
MacrophageBecomesNFKBDeactivatedInfected=NaN(ticks,runs);
MacrophageBecomesNFKBByCytoDeactivatedInfected=NaN(ticks,runs);
MacrophageBecomesNFKBByMtbDeactivatedInfected=NaN(ticks,runs);
MacrophageBecomesDeactivatedInfected=NaN(ticks,runs);
MacrophageBecomesSTAT1ActivatedUninfected=NaN(ticks,runs);
MacrophageBecomesNFKBActivatedUninfected=NaN(ticks,runs);
MacrophageBecomesNFKBActivatedByCytoUninfected=NaN(ticks,runs);
MacrophageBecomesNFKBActivatedByMtbUninfected=NaN(ticks,runs);
MacrophageBecomesTotallyActivatedUninfected=NaN(ticks,runs);
MacrophageBecomesSTAT1DeactivatedUninfected=NaN(ticks,runs);
MacrophageBecomesNFKBDeactivatedUninfected=NaN(ticks,runs);
MacrophageBecomesNFKBByCytoDeactivatedUninfected=NaN(ticks,runs);
MacrophageBecomesNFKBByMtbDeactivatedUninfected=NaN(ticks,runs);
MacrophageBecomesDeactivatedUninfected=NaN(ticks,runs);
ReactivationNFKB=NaN(ticks,runs);
ReactivationNFKBByCyto=NaN(ticks,runs);
ReactivationNFKBByMtb=NaN(ticks,runs);
ReactivationSTAT1=NaN(ticks,runs);
RestingMacrophageDeathCountFromCD8=NaN(ticks,runs);
ActivatedMacrophageDeathCountFromCD8=NaN(ticks,runs);
TotalMacrophageDeathCountFromCD8=NaN(ticks,runs);

MacrophageBecomesNFKBActivatedByTcell=NaN(ticks,runs);
MacrophageBecomesNFKBActivatedByTcellInfected=NaN(ticks,runs);
MacrophageBecomesNFKBActivatedByTcellUninfected=NaN(ticks,runs);
MacrophageBecomesNFKBByTcellDeactivated=NaN(ticks,runs);
MacrophageBecomesNFKBByTcellDeactivatedInfected=NaN(ticks,runs);
MacrophageBecomesNFKBByTcellDeactivatedUninfected=NaN(ticks,runs);
ReactivationNFKBByTcell=NaN(ticks,runs);

% Granuloma stats
immuneCellCountGran=NaN(ticks,runs);
infectedMacrophageCountGran=NaN(ticks,runs);
mtbCountGran=NaN(ticks,runs);
cd4CountGran=NaN(ticks,runs);
macrophageCountGran=NaN(ticks,runs);
intracellularMtbCountGran=NaN(ticks,runs);
extracellularMtbCountGran=NaN(ticks,runs);
xDimGran=NaN(ticks,runs);
yDimGran=NaN(ticks,runs);
zDimGran=NaN(ticks,runs);
xMaxGran =NaN(ticks,runs);
xMinGran =NaN(ticks,runs);
yMaxGran =NaN(ticks,runs);
yMinGran =NaN(ticks,runs);
idNumberGran=NaN(ticks,runs);
cd4ActivatedCountGran=NaN(ticks,runs);
cd4TBSpecificCountGran=NaN(ticks,runs);
cd4TotalCountGran=NaN(ticks,runs);
macrophageActivatedCountGran=NaN(ticks,runs);
macrophageTotalCountGran=NaN(ticks,runs);
CD4GeneratedCountGran=NaN(ticks,runs);
nonTBSpecificCD4CountGran=NaN(ticks,runs);
infectedMacrophageActivatedCountGran=NaN(ticks,runs);
uninfectedMacrophageCountGran=NaN(ticks,runs);
uninfectedMacrophageActivatedCountGran=NaN(ticks,runs);
Stat1OnlyActivatedMacrophagesGran=NaN(ticks,runs);
Stat1OnlyOfInfectedMacrophagesGran=NaN(ticks,runs);
Stat1OnlyOfUninfectedMacrophagesGran=NaN(ticks,runs);
Stat1TotalMacrophagesGran=NaN(ticks,runs);
NfkbTotalMacrophagesGran=NaN(ticks,runs);
NfkbOnlyActivatedMacrophagesGran=NaN(ticks,runs);
NfkbByMtbTotalMacrophagesGran=NaN(ticks,runs);
NfkbByMtbOnlyOfUninfectedMacrophagesGran=NaN(ticks,runs);
NfkbByMtbOnlyOfInfectedMacrophagesGran=NaN(ticks,runs);
NfkbByMtbOnlyActivatedMacrophagesGran=NaN(ticks,runs);
NfkbByMtbOfActivatedUninfectedMacrophagesGran=NaN(ticks,runs);
NfkbByMtbOfActivatedInfectedMacrophagesGran=NaN(ticks,runs);
NfkbByMtbActivatedMacrophagesGran=NaN(ticks,runs);
NfkbByCytoTotalMacrophagesGran=NaN(ticks,runs);
NfkbByCytoOnlyOfUninfectedMacrophagesGran=NaN(ticks,runs);
NfkbByCytoOnlyOfInfectedMacrophagesGran=NaN(ticks,runs);
NfkbByCytoOnlyActivatedMacrophagesGran=NaN(ticks,runs);
NfkbByCytoOfActivatedUninfectedMacrophagesGran=NaN(ticks,runs);
NfkbByCytoOfActivatedInfectedMacrophagesGran=NaN(ticks,runs);
NfkbByCytoActivatedMacrophagesGran=NaN(ticks,runs);
ChronicallyInfectedMacrophageCountGran=NaN(ticks,runs);

fprintf('Start Processing \n')
%% Combine data for AgentCounts
index = 0;

for m=1:height(countTable)
    x=countTable.tick(m);
    y=countTable.run(m);
    if x == 1
        index = index+1;
    end
    if(isnan(x) || isnan(y))
        continue;
    end
    totalMtbCount(x,index)=countTable.TotalMtb(m);
    totalCD4Count(x,index)=countTable.TotalCD4s(m);
    tbSpecificCD4Count(x,index)=countTable.TotalTB_SpecificCD4s(m);
    activatedCD4Count(x,index)=countTable.TotalActivatedCD4s(m);
    generatedCD4Count(x,index)=countTable.TotalGeneratedCD4s(m);
    nontbSpecificCD4Count(x,index) = countTable.TotalNonTB_SpecificCD4s(m);
    intracellularMtbCount(x,index)=countTable.TotalIntracellularMtb(m);
    extracellularMtbCount(x,index)=countTable.TotalExtracellularMtb(m);
    granulomaCount(x,index)=countTable.TotalGranulomas(m);
    totalMacroCount(x,index)=countTable.TotalMacros(m);
    infectedMacroCount(x,index)=countTable.TotalInfectedMacros(m);
    uninfectedMacroCount(x,index)=countTable.TotalUninfectedMacs(m);
    activatedMacroCount(x,index)=countTable.TotalActivatedMacrophages(m);
    activatedInfectedMacroCount(x,index)=countTable.TotalActivatedInfectedMacs(m);
    activatedUninfectedMacroCount(x,index) = countTable.TotalActivatedUninfectedMacs(m);
    
    totalStat1OnlyMacs(x,index) = countTable.TotalStat1OnlyMacs(m);
    totalNfkbByCytoOnlyMacs(x,index) = countTable.TotalNfkbByCytoOnlyMacs(m);
    totalNfkbByMtbOnlyMacs(x,index) = countTable.TotalNfkbByMtbOnlyMacs(m);
    totalNfkbOnlyMacs(x,index) = countTable.TotalNfkbOnlyMacs(m);
    
    nfkbbyCytoofActivatedInfectedMacs(x,index)=countTable.TotalNfkbByCytoActivatedInfectedMacs(m);
    nfkbbyCytoofActivatedUninfectedMacs(x,index)=countTable.TotalNfkbByCytoActivatedUninfectedMacs(m);
    nfkbByCytoOnlyInfMacs(x,index)=countTable.TotalNfkbByCytoOnlyInfectedMacs(m);
    nfkbByCytoOnlyUninfMacs(x,index)=countTable.TotalNfkbByCytoOnlyUninfectedMacs(m);
    nfkbByMtbOnlyUninfMacs(x,index)=countTable.TotalNfkbByMtbOnlyUninfectedMacs(m);
    nfkbByMtbOnlyInfMacs(x,index)=countTable.TotalNfkbByMtbOnlyInfectedMacs(m);
    nfkbbyMtbofActivatedInfectedMacs(x,index)=countTable.TotalNfkbByMtbActivatedInfectedMacs(m);
    nfkbbyMtbofActivatedUninfectedMacs(x,index)=countTable.TotalNfkbByMtbActivatedUninfectedMacs(m);
    stat1OnlyInfMacs(x,index)=countTable.TotalStat1OnlyInfectedMacs(m);
    stat1OnlyUninfMacs(x,index)=countTable.TotalStat1OnlyUninfectedMacs(m);
    totalStat1MacroCount(x,index)=countTable.TotalStat1Macs(m);
    totalNfkbMacroCount(x,index)=countTable.TotalNfkbMacs(m);
    
    totalNfkbByMtbMacs(x,index) = countTable.TotalNfkbByMtbMacs(m);
    totalNfkbByCytoMacs(x,index) = countTable.TotalNfkbByCytoMacs(m);
    totalNfkbByCytoOfActivatedMacs(x,index)=countTable.TotalNfkbByCytoOfActivatedMacs(m);
    totalNfkbByMtbOfActivatedMacs(x,index)=countTable.TotalNfkbByMtbOfActivatedMacs(m);
    
    totalChronicallyInfectedMacs(x,index) = countTable.TotalChronicallyInfectedMacrophages(m);
    totalTBSpecificCD8s(x,index)=countTable.TotalTB_SpecificCD8s(m);
    totalActivatedCD8s(x,index)=countTable.TotalActivatedCD8s(m);
    totalGeneratedCD8s(x,index)=countTable.TotalGeneratedCD8s(m);
    totalCD8(x,index)=countTable.TotalCD8(m);
    
    totalInfectedMacrophagesabovePhagocytosisThreshold(x,index)=countTable.TotalInfectedMacrophagesAbovePhagocytosisThreshold(m);
end
for m=1:runs 
    data(m).totalMtbCount=totalMtbCount(:,m);
    data(m).totalCD4Count=totalCD4Count(:,m);
    data(m).tbSpecificCD4Count=tbSpecificCD4Count(:,m);
    data(m).activatedCD4Count=activatedCD4Count(:,m);
    data(m).generatedCD4Count=generatedCD4Count(:,m);
    data(m).nontbSpecificCD4Count=nontbSpecificCD4Count(:,m);
    data(m).intracellularMtbCount=intracellularMtbCount(:,m);
    data(m).extracellularMtbCount=extracellularMtbCount(:,m);
    data(m).granulomaCount=granulomaCount(:,m);
    
    data(m).totalMacroCount=totalMacroCount(:,m);
    data(m).infectedMacroCount=infectedMacroCount(:,m);
    data(m).uninfectedMacroCount=uninfectedMacroCount(:,m);
    data(m).activatedMacroCount=activatedMacroCount(:,m);
    data(m).activatedInfectedMacroCount=activatedInfectedMacroCount(:,m);
    data(m).activatedUninfectedMacroCount=activatedUninfectedMacroCount(:,m);
    
    data(m).totalStat1OnlyMacs=totalStat1OnlyMacs(:,m);
    data(m).totalNfkbByCytoOnlyMacs=totalNfkbByCytoOnlyMacs(:,m);
    data(m).totalNfkbByMtbOnlyMacs=totalNfkbByMtbOnlyMacs(:,m);
    data(m).totalNfkbOnlyMacs=totalNfkbOnlyMacs(:,m);
    data(m).nfkbbyCytoofActivatedInfectedMacs=nfkbbyCytoofActivatedInfectedMacs(:,m);
    data(m).nfkbbyCytoofActivatedUninfectedMacs=nfkbbyCytoofActivatedUninfectedMacs(:,m);
    data(m).nfkbByCytoOnlyInfMacs=nfkbByCytoOnlyInfMacs(:,m);
    data(m).nfkbByCytoOnlyUninfMacs=nfkbByCytoOnlyUninfMacs(:,m);
    data(m).nfkbByMtbOnlyUninfMacs=nfkbByMtbOnlyUninfMacs(:,m);
    data(m).nfkbByMtbOnlyInfMacs=nfkbByMtbOnlyInfMacs(:,m);
    data(m).nfkbbyMtbofActivatedInfectedMacs=nfkbbyMtbofActivatedInfectedMacs(:,m);
    data(m).nfkbbyMtbofActivatedUninfectedMacs=nfkbbyMtbofActivatedUninfectedMacs(:,m);
    data(m).stat1OnlyInfMacs=stat1OnlyInfMacs(:,m);
    data(m).stat1OnlyUninfMacs=stat1OnlyUninfMacs(:,m);
    data(m).totalStat1MacroCount=totalStat1MacroCount(:,m);
    data(m).totalNfkbMacroCount=totalNfkbMacroCount(:,m);
    
    data(m).totalChronicallyInfectedMacs=totalChronicallyInfectedMacs(:,m);
    data(m).totalTBSpecificCD8s=totalTBSpecificCD8s(:,m);
    data(m).totalActivatedCD8s=totalActivatedCD8s(:,m);
    data(m).totalGeneratedCD8s=totalGeneratedCD8s(:,m);
    data(m).totalCD8=totalCD8(:,m);
    
    data(m).totalNfkbByMtbMacs=totalNfkbByMtbMacs(:,m);
    data(m).totalNfkbByCytoMacs=totalNfkbByCytoMacs(:,m);
    data(m).totalNfkbByCytoOfActivatedMacs=totalNfkbByCytoOfActivatedMacs(:,m);
    data(m).totalNfkbByMtbOfActivatedMacs=totalNfkbByMtbOfActivatedMacs(:,m);
    
    data(m).totalInfectedMacrophagesabovePhagocytosisThreshold=totalInfectedMacrophagesabovePhagocytosisThreshold(:,m);
    
end
fprintf('Agent Counts Complete\n')

%% Combine data for MtbEvents
index = 0;

for m=1:height(countTableM)
    x=countTableM.tick(m);
    y=countTableM.run(m);
    if x == 1
        index = index+1;
    end
    if(isnan(x) || isnan(y))
        continue;
    end
    mtbResistantCount(x,index)=countTableM.MtbResistantCount(m);
    mtbDivisionCount(x,index)=countTableM.MtbDivisionCount(m);
    mtbKilledCount(x,index)= countTableM.MtbTotalKilledCount(m);
    mtbKilledByActivatedMacCount(x,index) = countTableM.MtbKilledByActivatedMacCount(m);
    mtbKilledByRestingMacCount(x,index) = countTableM.MtbKilledByRestingMacCount(m);
    mtbKilledByCD8Count(x,index)=countTableM.MtbKilledByCD8Count(m);
end
for m=1:runs
    data(m).mtbResistantCount=mtbResistantCount(:,m);
    data(m).mtbDivisionCount=mtbDivisionCount(:,m);
    data(m).mtbKilledCount=mtbKilledCount(:,m);
    data(m).mtbKilledByActivatedMacCount=mtbKilledByActivatedMacCount(:,m);
    data(m).mtbKilledByRestingMacCount=mtbKilledByRestingMacCount(:,m);
    data(m).mtbKilledByCD8Count = mtbKilledByCD8Count(:,m);
end
fprintf('Mtb Events Complete\n')

%% Combine data for CD4Events
index = 0;
for m=1:height(countTableC)
    x=countTableC.tick(m);
    y=countTableC.run(m);
    if x == 1
        index = index+1;
    end
    if(isnan(x) || isnan(y))
        continue;
    end
    failedToGenerateCount(x,index)=countTableC.FailedToGenerateCount(m);
    activatedTBSpecificCD4DeathCount(x,index) = countTableC.TotalActivatedTBSpecificCD4DeathCount(m);
    restingTBSpecificCD4DeathCount(x,index) = countTableC.TotalRestingTBSpecificCD4DeathCount(m);
    TBSpecificCD4DeathCount(x,index) = countTableC.TotalTBSpecificCD4DeathCount(m);
    nonTBSpecificCD4DeathCount(x,index) = countTableC.TotalNonTBSpecificCD4DeathCount(m);
    totalCD4DeathCount(x,index) = countTableC.TotalCD4DeathCount(m);
    CD4BecomesActivated(x,index) = countTableC.CD4BecomesActivated(m);
    CD4BecomesDeactivated(x,index)=countTableC.CD4BecomesDeactivated(m);
    CD4ReachesMaxGenerations(x,index) = countTableC.CD4ReachesMaxGenerations(m);

end
for m=1:runs
    data(m).failedToGenerateCount=failedToGenerateCount(:,m);
    data(m).activatedTBSpecificCD4DeathCount = activatedTBSpecificCD4DeathCount(:,m);
    data(m).restingTBSpecificCD4DeathCount = restingTBSpecificCD4DeathCount(:,m);
    data(m).TBSpecificCD4DeathCount = TBSpecificCD4DeathCount(:,m);
    data(m).nonTBSpecificCD4DeathCount = nonTBSpecificCD4DeathCount(:,m);
    data(m).totalCD4DeathCount = totalCD4DeathCount(:,m);
    data(m).CD4BecomesActivated = CD4BecomesActivated(:,m);
    data(m).CD4BecomesDeactivated=CD4BecomesDeactivated(:,m);
    data(m).CD4ReachesMaxGenerations = CD4ReachesMaxGenerations(:,m);
end
fprintf('CD4 Events Complete\n')
%% Combine data for CD8Events
index =0;
for m=1:height(countTableCD8)
    x=countTableCD8.tick(m);
    y=countTableCD8.run(m);
    if x == 1
        index = index+1;
    end
    if(isnan(x) || isnan(y))
        continue;
    end
    FailedToGenerateCD8Count(x,index)=countTableCD8.FailedToGenerateCD8Count(m);
    activatedTBSpecificCD8DeathCount(x,index) = countTableCD8.TotalActivatedTBSpecificCD8DeathCount(m);
    restingTBSpecificCD8DeathCount(x,index) = countTableCD8.TotalRestingTBSpecificCD8DeathCount(m);
    TBSpecificCD8DeathCount(x,index) = countTableCD8.TotalTBSpecificCD8DeathCount(m);
    nonTBSpecificCD8DeathCount(x,index) = countTableCD8.TotalNonTBSpecificCD8DeathCount(m);
    totalCD8DeathCount(x,index) = countTableCD8.TotalCD8DeathCount(m);
    CD8BecomesActivated(x,index) = countTableCD8.CD8BecomesActivated(m);
    CD8BecomesDeactivated(x,index)=countTableCD8.CD8BecomesDeactivated(m);
    CD8ReachesMaxGenerations(x,index) = countTableCD8.CD8ReachesMaxGenerations(m);
    CD8KillsBac(x,index)=countTableCD8.CD8KillsBac(m);
    CD8KillsMac(x,index) = countTableCD8.CD8KillsMac(m);

end
for m=1:runs
    data(m).failedToGenerateCD8Count=FailedToGenerateCD8Count(:,m);
    data(m).activatedTBSpecificCD8DeathCount = activatedTBSpecificCD8DeathCount(:,m);
    data(m).restingTBSpecificCD8DeathCount = restingTBSpecificCD8DeathCount(:,m);
    data(m).TBSpecificCD8DeathCount = TBSpecificCD8DeathCount(:,m);
    data(m).nonTBSpecificCD8DeathCount = nonTBSpecificCD8DeathCount(:,m);
    data(m).totalCD8DeathCount = totalCD8DeathCount(:,m);
    data(m).CD8BecomesActivated = CD8BecomesActivated(:,m);
    data(m).CD8BecomesDeactivated=CD8BecomesDeactivated(:,m);
    data(m).CD8ReachesMaxGenerations = CD8ReachesMaxGenerations(:,m);
    data(m).CD8KillsBac= CD8KillsBac(:,m);
    data(m).CD8KillsMac = CD8KillsMac(:,m);
    
end
fprintf('CD8 Events Complete\n')

%% Combine data for ElapsedTime
for m=1:height(countTableE)
    data(m).Time=countTableE.Time(m);
end
fprintf('Elapsed Time Complete\n')
%% Combine data for MacrophageEvents
index=0;

for m=1:height(countTableMD)
    x=countTableMD.tick(m);
    y=countTableMD.run(m);
    if x == 1
        index = index+1;
    end
    if(isnan(x) || isnan(y))
        continue;
    end
    ActivatedInfectedMacrophageDeathCountFromOldAge(x,index)=countTableMD.ActivatedInfectedMacrophageDeathCountFromOldAge(m);
    RestingInfectedMacrophageDeathCountFromOldAge(x,index)=countTableMD.RestingInfectedMacrophageDeathCountFromOldAge(m);
    TotalInfectedMacrophageDeathsFromOldAge(x,index)=countTableMD.TotalInfectedMacrophageDeathsFromOldAge(m);
    ActivatedUninfectedMacrophageDeathCountFromOldAge(x,index)=countTableMD.ActivatedUninfectedMacrophageDeathCountFromOldAge(m);
    RestingUninfectedMacrophageDeathCountFromOldAge(x,index)=countTableMD.RestingUninfectedMacrophageDeathCountFromOldAge(m);
    TotalUninfectedMacrophageDeathsFromOldAge(x,index)=countTableMD.TotalUninfectedMacrophageDeathsFromOldAge(m);
    ActivatedMacrophageDeathCountFromBursting(x,index)=countTableMD.ActivatedMacrophageDeathCountFromBursting(m);
    RestingMacrophageDeathCountFromBursting(x,index)=countTableMD.RestingMacrophageDeathCountFromBursting(m);
    TotalMacrophageDeathCountFromBursting(x,index)=countTableMD.TotalMacrophageDeathCountFromBursting(m);
    TotalActivatedMacrophageDeathCountFromOldAge(x,index)=countTableMD.TotalActivatedMacrophageDeathCountFromOldAge(m);
    TotalMacrophageDeathCountFromOldAge(x,index)=countTableMD.TotalMacrophageDeathCountFromOldAge(m);
    TotalRestingMacrophageDeathCountFromOldAge(x,index)=countTableMD.TotalRestingMacrophageDeathCountFromOldAge(m);
    TotalMacrophageDeaths(x,index)=countTableMD.TotalMacrophageDeaths(m);
    MacrophageBecomesInfected(x,index)=countTableMD.MacrophageBecomesInfected(m);
    MacrophageBecomesUninfected(x,index)=countTableMD.MacrophageBecomesUninfected(m);
    MacrophageInteractedWithMtbFirst(x,index)=countTableMD.MacrophageInteractedWithMtbFirst(m);
    MacrophageInteractedWithMtbTotal(x,index)=countTableMD.MacrophageInteractedWithMtbTotal(m);
    InfectedMacrosFightInfection(x,index)=countTableMD.InfectedMacrosFightInfection(m);
    MacrophagePhagocytosesMtbInfected(x,index)=countTableMD.MacrophagePhagocytosesMtbInfected(m);
    MacrophagePhagocytosesMtbUninfected(x,index)=countTableMD.MacrophagePhagocytosesMtbUninfected(m);
    MacrophagePhagocytosesMtbBaseInfected(x,index)=countTableMD.MacrophagePhagocytosesMtbBaseInfected(m);
    MacrophagePhagocytosesMtbBaseUninfected(x,index)=countTableMD.MacrophagePhagocytosesMtbBaseUninfected(m);
    MacrophagePhagocytosesMtbActivatedInfected(x,index)=countTableMD.MacrophagePhagocytosesMtbActivatedInfected(m);
    MacrophagePhagocytosesMtbActivatedUninfected(x,index)=countTableMD.MacrophagePhagocytosesMtbActivatedUninfected(m);
    MacrophageBecomesSTAT1Activated(x,index)=countTableMD.MacrophageBecomesSTAT1Activated(m);
    MacrophageBecomesNFKBActivated(x,index)=countTableMD.MacrophageBecomesNFKBActivated(m);
    MacrophageBecomesNFKBActivatedByCyto(x,index)=countTableMD.MacrophageBecomesNFKBActivatedByCyto(m);
    MacrophageBecomesNFKBActivatedByMtb(x,index)=countTableMD.MacrophageBecomesNFKBActivatedByMtb(m);
    MacrophageBecomesTotallyActivated(x,index)=countTableMD.MacrophageBecomesTotallyActivated(m);
    MacrophageBecomesSTAT1Deactivated(x,index)=countTableMD.MacrophageBecomesSTAT1Deactivated(m);
    MacrophageBecomesNFKBDeactivated(x,index)=countTableMD.MacrophageBecomesNFKBDeactivated(m);
    MacrophageBecomesNFKBByCytoDeactivated(x,index)=countTableMD.MacrophageBecomesNFKBByCytoDeactivated(m);
    MacrophageBecomesNFKBByMtbDeactivated(x,index)=countTableMD.MacrophageBecomesNFKBByMtbDeactivated(m);
    MacrophageBecomesDeactivated(x,index)=countTableMD.MacrophageBecomesDeactivated(m);
    MacrophageBecomesSTAT1ActivatedInfected(x,index)=countTableMD.MacrophageBecomesSTAT1ActivatedInfected(m);
    MacrophageBecomesNFKBActivatedInfected(x,index)=countTableMD.MacrophageBecomesNFKBActivatedInfected(m);
    MacrophageBecomesNFKBActivatedByCytoInfected(x,index)=countTableMD.MacrophageBecomesNFKBActivatedByCytoInfected(m);
    MacrophageBecomesNFKBActivatedByMtbInfected(x,index)=countTableMD.MacrophageBecomesNFKBActivatedByMtbInfected(m);
    MacrophageBecomesTotallyActivatedInfected(x,index)=countTableMD.MacrophageBecomesTotallyActivatedInfected(m);
    MacrophageBecomesSTAT1DeactivatedInfected(x,index)=countTableMD.MacrophageBecomesSTAT1DeactivatedInfected(m);
    MacrophageBecomesNFKBDeactivatedInfected(x,index)=countTableMD.MacrophageBecomesNFKBDeactivatedInfected(m);
    MacrophageBecomesNFKBByCytoDeactivatedInfected(x,index)=countTableMD.MacrophageBecomesNFKBByCytoDeactivatedInfected(m);
    MacrophageBecomesNFKBByMtbDeactivatedInfected(x,index)=countTableMD.MacrophageBecomesNFKBByMtbDeactivatedInfected(m);
    MacrophageBecomesDeactivatedInfected(x,index)=countTableMD.MacrophageBecomesDeactivatedInfected(m);
    MacrophageBecomesSTAT1ActivatedUninfected(x,index)=countTableMD.MacrophageBecomesSTAT1ActivatedUninfected(m);
    MacrophageBecomesNFKBActivatedUninfected(x,index)=countTableMD.MacrophageBecomesNFKBActivatedUninfected(m);
    MacrophageBecomesNFKBActivatedByCytoUninfected(x,index)=countTableMD.MacrophageBecomesNFKBActivatedByCytoUninfected(m);
    MacrophageBecomesNFKBActivatedByMtbUninfected(x,index)=countTableMD.MacrophageBecomesNFKBActivatedByMtbUninfected(m);
    MacrophageBecomesTotallyActivatedUninfected(x,index)=countTableMD.MacrophageBecomesTotallyActivatedUninfected(m);
    MacrophageBecomesSTAT1DeactivatedUninfected(x,index)=countTableMD.MacrophageBecomesSTAT1DeactivatedUninfected(m);
    MacrophageBecomesNFKBDeactivatedUninfected(x,index)=countTableMD.MacrophageBecomesNFKBDeactivatedUninfected(m);
    MacrophageBecomesNFKBByCytoDeactivatedUninfected(x,index)=countTableMD.MacrophageBecomesNFKBByCytoDeactivatedUninfected(m);
    MacrophageBecomesNFKBByMtbDeactivatedUninfected(x,index)=countTableMD.MacrophageBecomesNFKBByMtbDeactivatedUninfected(m);
    MacrophageBecomesDeactivatedUninfected(x,index)=countTableMD.MacrophageBecomesDeactivatedUninfected(m);
    ReactivationNFKB(x,index)=countTableMD.ReactivationNFKB(m);
    ReactivationNFKBByCyto(x,index)=countTableMD.ReactivationNFKBByCyto(m);
    ReactivationNFKBByMtb(x,index)=countTableMD.ReactivationNFKBByMtb(m);
    ReactivationSTAT1(x,index)=countTableMD.ReactivationSTAT1(m);
    
    RestingMacrophageDeathCountFromCD8(x,index)=countTableMD.RestingMacrophageDeathCountFromCD8(m);
    ActivatedMacrophageDeathCountFromCD8(x,index)=countTableMD.ActivatedMacrophageDeathCountFromCD8(m);
    TotalMacrophageDeathCountFromCD8(x,index)=countTableMD.TotalMacrophageDeathCountFromCD8(m);
    
    MacrophageBecomesNFKBActivatedByTcell(x,index) = countTableMD.MacrophageBecomesNFKBActivatedByTcell(m);
    MacrophageBecomesNFKBActivatedByTcellInfected(x,index) = countTableMD.MacrophageBecomesNFKBActivatedByTcellInfected(m);
    MacrophageBecomesNFKBActivatedByTcellUninfected(x,index) = countTableMD.MacrophageBecomesNFKBActivatedByTcellUninfected(m);
    MacrophageBecomesNFKBByTcellDeactivated(x,index) = countTableMD.MacrophageBecomesNFKBByTcellDeactivated(m);
    MacrophageBecomesNFKBByTcellDeactivatedInfected(x,index) = countTableMD.MacrophageBecomesNFKBByTcellDeactivatedInfected(m);
    MacrophageBecomesNFKBByTcellDeactivatedUninfected(x,index) = countTableMD.MacrophageBecomesNFKBByTcellDeactivatedUninfected(m);
    ReactivationNFKBByTcell(x,index) = countTableMD.ReactivationNFKBByTcell(m);

end
for m=1:runs
    data(m).ActivatedInfectedMacrophageDeathCountFromOldAge=ActivatedInfectedMacrophageDeathCountFromOldAge(:,m);
    data(m).RestingInfectedMacrophageDeathCountFromOldAge=RestingInfectedMacrophageDeathCountFromOldAge(:,m);
    data(m).TotalInfectedMacrophageDeathsFromOldAge=TotalInfectedMacrophageDeathsFromOldAge(:,m);
    data(m).ActivatedUninfectedMacrophageDeathCountFromOldAge=ActivatedUninfectedMacrophageDeathCountFromOldAge(:,m);
    data(m).RestingUninfectedMacrophageDeathCountFromOldAge=RestingUninfectedMacrophageDeathCountFromOldAge(:,m);
    data(m).TotalUninfectedMacrophageDeathsFromOldAge=TotalUninfectedMacrophageDeathsFromOldAge(:,m);
    data(m).ActivatedMacrophageDeathCountFromBursting=ActivatedMacrophageDeathCountFromBursting(:,m);
    data(m).RestingMacrophageDeathCountFromBursting=RestingMacrophageDeathCountFromBursting(:,m);
    data(m).TotalMacrophageDeathCountFromBursting=TotalMacrophageDeathCountFromBursting(:,m);
    data(m).TotalActivatedMacrophageDeathCountFromOldAge=TotalActivatedMacrophageDeathCountFromOldAge(:,m);
    data(m).TotalMacrophageDeathCountFromOldAge=TotalMacrophageDeathCountFromOldAge(:,m);
    data(m).TotalRestingMacrophageDeathCountFromOldAge=TotalRestingMacrophageDeathCountFromOldAge(:,m);
    data(m).TotalMacrophageDeaths=TotalMacrophageDeaths(:,m);
    data(m).MacrophageBecomesInfected=MacrophageBecomesInfected(:,m);
    data(m).MacrophageBecomesUninfected=MacrophageBecomesUninfected(:,m);
    data(m).MacrophageInteractedWithMtbFirst=MacrophageInteractedWithMtbFirst(:,m);
    data(m).MacrophageInteractedWithMtbTotal=MacrophageInteractedWithMtbTotal(:,m);
    data(m).InfectedMacrosFightInfection=InfectedMacrosFightInfection(:,m);
    data(m).MacrophagePhagocytosesMtbInfected=MacrophagePhagocytosesMtbInfected(:,m);
    data(m).MacrophagePhagocytosesMtbUninfected=MacrophagePhagocytosesMtbUninfected(:,m);
    data(m).MacrophagePhagocytosesMtbBaseInfected=MacrophagePhagocytosesMtbBaseInfected(:,m);
    data(m).MacrophagePhagocytosesMtbBaseUninfected=MacrophagePhagocytosesMtbBaseUninfected(:,m);
    data(m).MacrophagePhagocytosesMtbActivatedInfected=MacrophagePhagocytosesMtbActivatedInfected(:,m);
    data(m).MacrophagePhagocytosesMtbActivatedUninfected=MacrophagePhagocytosesMtbActivatedUninfected(:,m);
    data(m).MacrophageBecomesSTAT1Activated=MacrophageBecomesSTAT1Activated(:,m);
    data(m).MacrophageBecomesNFKBActivated=MacrophageBecomesNFKBActivated(:,m);
    data(m).MacrophageBecomesNFKBActivatedByCyto=MacrophageBecomesNFKBActivatedByCyto(:,m);
    data(m).MacrophageBecomesNFKBActivatedByMtb=MacrophageBecomesNFKBActivatedByMtb(:,m);
    data(m).MacrophageBecomesTotallyActivated=MacrophageBecomesTotallyActivated(:,m);
    data(m).MacrophageBecomesSTAT1Deactivated=MacrophageBecomesSTAT1Deactivated(:,m);
    data(m).MacrophageBecomesNFKBDeactivated=MacrophageBecomesNFKBDeactivated(:,m);
    data(m).MacrophageBecomesNFKBByCytoDeactivated=MacrophageBecomesNFKBByCytoDeactivated(:,m);
    data(m).MacrophageBecomesNFKBByMtbDeactivated=MacrophageBecomesNFKBByMtbDeactivated(:,m);
    data(m).MacrophageBecomesDeactivated=MacrophageBecomesDeactivated(:,m);
    data(m).MacrophageBecomesSTAT1ActivatedInfected=MacrophageBecomesSTAT1ActivatedInfected(:,m);
    data(m).MacrophageBecomesNFKBActivatedInfected=MacrophageBecomesNFKBActivatedInfected(:,m);
    data(m).MacrophageBecomesNFKBActivatedByCytoInfected=MacrophageBecomesNFKBActivatedByCytoInfected(:,m);
    data(m).MacrophageBecomesNFKBActivatedByMtbInfected=MacrophageBecomesNFKBActivatedByMtbInfected(:,m);
    data(m).MacrophageBecomesTotallyActivatedInfected=MacrophageBecomesTotallyActivatedInfected(:,m);
    data(m).MacrophageBecomesSTAT1DeactivatedInfected=MacrophageBecomesSTAT1DeactivatedInfected(:,m);
    data(m).MacrophageBecomesNFKBDeactivatedInfected=MacrophageBecomesNFKBDeactivatedInfected(:,m);
    data(m).MacrophageBecomesNFKBByCytoDeactivatedInfected=MacrophageBecomesNFKBByCytoDeactivatedInfected(:,m);
    data(m).MacrophageBecomesNFKBByMtbDeactivatedInfected=MacrophageBecomesNFKBByMtbDeactivatedInfected(:,m);
    data(m).MacrophageBecomesDeactivatedInfected=MacrophageBecomesDeactivatedInfected(:,m);
    data(m).MacrophageBecomesSTAT1ActivatedUninfected=MacrophageBecomesSTAT1ActivatedUninfected(:,m);
    data(m).MacrophageBecomesNFKBActivatedUninfected=MacrophageBecomesNFKBActivatedUninfected(:,m);
    data(m).MacrophageBecomesNFKBActivatedByCytoUninfected=MacrophageBecomesNFKBActivatedByCytoUninfected(:,m);
    data(m).MacrophageBecomesNFKBActivatedByMtbUninfected=MacrophageBecomesNFKBActivatedByMtbUninfected(:,m);
    data(m).MacrophageBecomesTotallyActivatedUninfected=MacrophageBecomesTotallyActivatedUninfected(:,m);
    data(m).MacrophageBecomesSTAT1DeactivatedUninfected=MacrophageBecomesSTAT1DeactivatedUninfected(:,m);
    data(m).MacrophageBecomesNFKBDeactivatedUninfected=MacrophageBecomesNFKBDeactivatedUninfected(:,m);
    data(m).MacrophageBecomesNFKBByCytoDeactivatedUninfected=MacrophageBecomesNFKBByCytoDeactivatedUninfected(:,m);
    data(m).MacrophageBecomesNFKBByMtbDeactivatedUninfected=MacrophageBecomesNFKBByMtbDeactivatedUninfected(:,m);
    data(m).MacrophageBecomesDeactivatedUninfected=MacrophageBecomesDeactivatedUninfected(:,m);
    data(m).ReactivationNFKB=ReactivationNFKB(:,m);
    data(m).ReactivationNFKBByCyto=ReactivationNFKBByCyto(:,m);
    data(m).ReactivationNFKBByMtb=ReactivationNFKBByMtb(:,m);
    data(m).ReactivationSTAT1=ReactivationSTAT1(:,m);
    
    data(m).RestingMacrophageDeathCountFromCD8=RestingMacrophageDeathCountFromCD8(:,m);
    data(m).ActivatedMacrophageDeathCountFromCD8=ActivatedMacrophageDeathCountFromCD8(:,m);
    data(m).TotalMacrophageDeathCountFromCD8=TotalMacrophageDeathCountFromCD8(:,m);
    
    data(m).MacrophageBecomesNFKBActivatedByTcell=MacrophageBecomesNFKBActivatedByTcell(:,m);
    data(m).MacrophageBecomesNFKBActivatedByTcellInfected=MacrophageBecomesNFKBActivatedByTcellInfected(:,m);
    data(m).MacrophageBecomesNFKBActivatedByTcellUninfected=MacrophageBecomesNFKBActivatedByTcellUninfected(:,m);
    data(m).MacrophageBecomesNFKBByTcellDeactivated=MacrophageBecomesNFKBByTcellDeactivated(:,m);
    data(m).MacrophageBecomesNFKBByTcellDeactivatedInfected=MacrophageBecomesNFKBByTcellDeactivatedInfected(:,m);
    data(m).MacrophageBecomesNFKBByTcellDeactivatedUninfected=MacrophageBecomesNFKBByTcellDeactivatedUninfected(:,m);
    data(m).ReactivationNFKBByTcell=ReactivationNFKBByTcell(:,m);
end
fprintf('Macrophage Events Complete\n')
% % % This is for reduced counts, like if you wanted every 40th number.
% for m=1:length(data)
%             data(m).bacCountsRed=bacCount(1:40:2935,m);
%             data(m).immuneCellCountsRed=immuneCellCount(1:40:2935,m);
%             data(m).cd4CountsRed=cd4Count(1:40:2935,m);
%             data(m).infectedMacrophageCountsRed=infectedMacrophageCount(1:40:2935,m);
%             data(m).macrophageCountsRed=macrophageCount(1:40:2935,m);
%     data(m).granulomaCountsRed=granulomaCount(1:240:ticks,m);
% end

% %% Combine data for Granuloma Stats
% for m=1:height(countTableG)
%     x=countTableG.tick(m)
%     y=countTableG.run(m)
%     if(isnan(x) || isnan(y))
%         continue;
%     end
%     immuneCellCountGran(x,y)=countTableG.ImmuneCellCount(m);
%     mtbCountGran(x,y)=countTableG.MtbCount(m);
%     infectedMacrophageCountGran(x,y)=countTableG.InfectedMacrophageCount(m);
%     intracellularMtbCountGran(x,y)=countTableG.IntracellularMtbCount(m);
%     extracellularMtbCountGran(x,y)=countTableG.ExtracellularMtbCount(m);
%     xDimGran(x,y)=countTableG.Xdim(m);
%     yDimGran(x,y)=countTableG.Ydim(m);
%     zDimGran(x,y)=countTableG.Zdim(m);
%     xMaxGran(x,y) =countTableG.XMax(m);
%     xMinGran(x,y) =countTableG.XMin(m);
%     yMaxGran(x,y) =countTableG.YMax(m);
%     yMinGran(x,y) =countTableG.YMin(m);
%     idNumberGran(x,y)=countTableG.IDNumber(m);
%     cd4ActivatedCountGran(x,y)=countTableG.CD4ActivatedCount(m);
%     cd4TBSpecificCountGran(x,y)=countTableG.CD4TBSpecificCount(m);
%     cd4TotalCountGran(x,y)=countTableG.CD4TotalCount(m);
%     macrophageActivatedCountGran(x,y)=countTableG.MacrophageActivatedCount(m);
%     macrophageTotalCountGran(x,y)=countTableG.MacrophageTotalCount(m);
%     CD4GeneratedCountGran(x,y)=countTableG.CD4GeneratedCount(m);
%     nonTBSpecificCD4CountGran(x,y)=countTableG.NonTBSpecificCD4Count(m);
%     infectedMacrophageActivatedCountGran(x,y)=countTableG.InfectedMacrophageActivatedCount(m);
%     uninfectedMacrophageCountGran(x,y)=countTableG.UninfectedMacrophageCount(m);
%     uninfectedMacrophageActivatedCountGran(x,y)=countTableG.UninfectedMacrophageActivatedCount(m);
%     Stat1OnlyOfInfectedMacrophagesGran(x,y)=countTableG.Stat1OnlyOfInfectedMacrophages(m);
%     Stat1OnlyOfUninfectedMacrophagesGran(x,y)=countTableG.Stat1OnlyOfUninfectedMacrophages(m);
%     Stat1TotalMacrophagesGran(x,y)=countTableG.Stat1TotalMacrophages(m);
%     NfkbTotalMacrophagesGran(x,y)=countTableG.NfkbTotalMacrophages(m);
%     NfkbByMtbTotalMacrophagesGran(x,y)=countTableG.NfkbByMtbTotalMacrophages(m);
%     NfkbByMtbOnlyOfUninfectedMacrophagesGran(x,y)=countTableG.NfkbByMtbOnlyOfUninfectedMacrophages(m);
%     NfkbByMtbOnlyOfInfectedMacrophagesGran(x,y)=countTableG.NfkbByMtbOnlyOfInfectedMacrophages(m);
%     NfkbByMtbOfActivatedUninfectedMacrophagesGran(x,y)=countTableG.NfkbByMtbOfActivatedUninfectedMacrophages(m);
%     NfkbByMtbOfActivatedInfectedMacrophagesGran(x,y)=countTableG.NfkbByMtbOfActivatedInfectedMacrophages(m);
%     NfkbByCytoTotalMacrophagesGran(x,y)=countTableG.NfkbByCytoTotalMacrophages(m);
%     NfkbByCytoOnlyOfUninfectedMacrophagesGran(x,y)=countTableG.NfkbByCytoOnlyOfUninfectedMacrophages(m);
%     NfkbByCytoOnlyOfInfectedMacrophagesGran(x,y)=countTableG.NfkbByCytoOnlyOfInfectedMacrophages(m);
%     NfkbByCytoOfActivatedUninfectedMacrophagesGran(x,y)=countTableG.NfkbByCytoOfActivatedUninfectedMacrophages(m);
%     NfkbByCytoOfActivatedInfectedMacrophagesGran(x,y)=countTableG.NfkbByCytoOfActivatedInfectedMacrophages(m);
%     Stat1OnlyMacrophagesGran(x,y)=countTableG.Stat1OnlyMacrophages(m);
%     NfkbOnlyMacrophagesGran(x,y)=countTableG.NfkbOnlyMacrophages(m);
%     NfkbByMtbOnlyMacrophagesGran(x,y)=countTableG.NfkbByMtbOnlyMacrophages(m);
%     NfkbByCytoOnlyMacrophagesGran(x,y)=countTableG.NfkbByCytoOnlyMacrophages(m);
%     NfkbByCytoOfActivatedMacrophagesGran(x,y)=countTableG.NfkbByCytoOfActivatedMacrophages(m);
%     NfkbByMtbOfActivatedMacrophagesGran(x,y)=countTableG.NfkbByMtbOfActivatedMacrophages(m);
%     ChronicallyInfectedMacrophageCountGran(x,y)=countTableG.ChronicallyInfectedMacrophageCount(m);
% end
% for m=1:max(countTable.run)
%     data(m).immuneCellCountsGran=immuneCellCountGran(:,m);
%     data(m).mtbCountsGran=mtbCountGran(:,m);
%     data(m).infectedMacrophagesCountsGran=infectedMacrophageCountGran(:,m);
%     data(m).intracellularMtbCountsGran=intracellularMtbCountGran(:,m);
%     data(m).extracellularMtbCountsGran=extracellularMtbCountGran(:,m);
%     data(m).xDimGran=xDimGran(:,m);
%     data(m).yDimGran=yDimGran(:,m);
%     data(m).zDimGran=zDimGran(:,m);
%     data(m).xMaxGran=xMaxGran(:,m);
%     data(m).xMinGran=xMinGran(:,m);
%     data(m).yMaxGran=yMaxGran(:,m);
%     data(m).yMinGran=yMinGran(:,m);
%     data(m).idNumberGran=idNumberGran(:,m);
%     data(m).cd4ActivatedCountsGran=cd4ActivatedCountGran(:,m);
%     data(m).cd4TBSpecificCountsGran=cd4TBSpecificCountGran(:,m);
%     data(m).cd4TotalCountsGran=cd4TotalCountGran(:,m);
%     data(m).macrophageActivatedCountsGran= macrophageActivatedCountGran(:,m);
%     data(m).macrophageTotalCountsGran= macrophageTotalCountGran(:,m);
%     data(m).CD4GeneratedCountGran=CD4GeneratedCountGran(:,m);
%     data(m).nonTBSpecificCD4CountGran=nonTBSpecificCD4CountGran(:,m);
%     data(m).infectedMacrophageActivatedCountGran=infectedMacrophageActivatedCountGran(:,m);
%     data(m).uninfectedMacrophageCountGran=uninfectedMacrophageCountGran(:,m);
%     data(m).uninfectedMacrophageActivatedCountGran=uninfectedMacrophageActivatedCountGran(:,m);
%     data(m).Stat1OnlyOfInfectedMacrophagesGran=Stat1OnlyOfInfectedMacrophagesGran(:,m);
%     data(m).Stat1OnlyOfUninfectedMacrophagesGran=Stat1OnlyOfUninfectedMacrophagesGran(:,m);
%     data(m).Stat1TotalMacrophagesGran=Stat1TotalMacrophagesGran(:,m);
%     data(m).NfkbTotalMacrophagesGran=NfkbTotalMacrophagesGran(:,m);
%     data(m).NfkbByMtbTotalMacrophagesGran=NfkbByMtbTotalMacrophagesGran(:,m);
%     data(m).NfkbByMtbOnlyOfUninfectedMacrophagesGran=NfkbByMtbOnlyOfUninfectedMacrophagesGran(:,m);
%     data(m).NfkbByMtbOnlyOfInfectedMacrophagesGran=NfkbByMtbOnlyOfInfectedMacrophagesGran(:,m);
%     data(m).NfkbByMtbOfActivatedUninfectedMacrophagesGran=NfkbByMtbOfActivatedUninfectedMacrophagesGran(:,m);
%     data(m).NfkbByMtbOfActivatedInfectedMacrophagesGran=NfkbByMtbOfActivatedInfectedMacrophagesGran(:,m);
%     data(m).NfkbByCytoTotalMacrophagesGran=NfkbByCytoTotalMacrophagesGran(:,m);
%     data(m).NfkbByCytoOnlyOfUninfectedMacrophagesGran=NfkbByCytoOnlyOfUninfectedMacrophagesGran(:,m);
%     data(m).NfkbByCytoOnlyOfInfectedMacrophagesGran=NfkbByCytoOnlyOfInfectedMacrophagesGran(:,m);
%     data(m).NfkbByCytoOfActivatedUninfectedMacrophagesGran=NfkbByCytoOfActivatedUninfectedMacrophagesGran(:,m);
%     data(m).NfkbByCytoOfActivatedInfectedMacrophagesGran=NfkbByCytoOfActivatedInfectedMacrophagesGran(:,m);
%     data(m).Stat1OnlyMacrophagesGran=Stat1OnlyMacrophagesGran(:,m);
%     data(m).NfkbOnlyMacrophagesGran=NfkbOnlyMacrophagesGran(:,m);
%     data(m).NfkbByMtbOnlyMacrophagesGran=NfkbByMtbOnlyMacrophagesGran(:,m);
%     data(m).NfkbByCytoOnlyMacrophagesGran=NfkbByCytoOnlyMacrophagesGran(:,m);
%     data(m).NfkbByCytoOfActivatedMacrophagesGran=NfkbByCytoOfActivatedMacrophagesGran(:,m);
%     data(m).NfkbByMtbOfActivatedMacrophagesGran=NfkbByMtbOfActivatedMacrophagesGran(:,m);
%     data(m).ChronicallyInfectedMacrophageCountGran=ChronicallyInfectedMacrophageCountGran(:,m);
% end
% 

%% Add parameters to data structure
for m=1:runs
    names=paramsTable.Properties.VariableNames;
    for n=1:length(names)
        data(m).(names{n})=paramsTable{m,n};
    end
end

fprintf('Parameters Complete\n')


%% Sort struture to make it comparable to others
T = struct2table(data); % convert the struct array to a table
T.run
sortedT = sortrows(T, {'run', 'CD8Fraction'}); % sort the table by 'DOB' and 
sortedT.run
data = table2struct(sortedT);

%% Save data %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Once data has been read into table, save it in a data structure
save(dataTitle, 'data', '-v7.3')
fprintf('Saved and Finished\n')