diff --git a/Pv_mod/Individual.cpp b/Pv_mod/Individual.cpp
index 5aa7f99db3661dff16b2c3295ec96f06b6ae295b..6ec8874236a8c9aeeb5323d94440a680dc3de5b0 100644
--- a/Pv_mod/Individual.cpp
+++ b/Pv_mod/Individual.cpp
@@ -67,6 +67,8 @@ void Individual::state_mover(Params& theta, double lam_bite)
 	PQ_treat = 0;
 	TQ_treat = 0;
 
+	G6PD_test = 0;
+
 	PQ_effective = 0;
 	PQ_overtreat = 0;
 	PQ_overtreat_9m = 0;
@@ -981,13 +983,15 @@ void Individual::case_management(Params& theta)
 		I_LM_new  = 1;
 		I_D_new   = 1;
 
+		G6PD_test = 0;
+
 		T_last_BS = 0.0;
 	}
 
 
 	/////////////////////////////////////////////////////////////////////
 	// Primaquine treatment regimen: blood-stage drugs and primaquine
-	// This is based on Narimane's tafenoquine treatment pathway.
+	// This is based on Narimane's primaquine treatment pathway.
 
 	if (theta.treat_regimen == 1)
 	{
@@ -1007,6 +1011,8 @@ void Individual::case_management(Params& theta)
 		I_LM_new  = 1;
 		I_D_new   = 1;
 
+		G6PD_test = 0;
+
 		T_last_BS = 0.0;
 
 
@@ -1030,8 +1036,18 @@ void Individual::case_management(Params& theta)
 				PQ_treat = 0;
 			}
 
+			//////////////////////////////////////////////////////////////////////////////////////////
+			// Is G6PD testing administered to those >6 months and not pregnant? If so, count test
+
+			if ((PQ_treat == 1) && (theta.PQ_G6PD_test == 1))
+			{
+				G6PD_test = 1;
+			}
+			
 			/////////////////////////////////////////////////////////////////////
-			// Exclude PQ because of G6PD deficiency
+			// Exclude PQ because of G6PD deficiency if there is testing
+
+			if ((theta.PQ_G6PD_test == 1) && (theta.PQ_G6PD_risk == 1) && (G6PD_activity < 4.0))
 
 			if ((theta.PQ_G6PD_risk == 1) && (G6PD_activity < 4.0))
 			{
@@ -1048,6 +1064,17 @@ void Individual::case_management(Params& theta)
 				PQ_effective = 1;
 			}
 
+			/////////////////////////////////////////////////////////////////////
+			// Is PQ adhered to?
+
+			if (genunf(0.0, 1.0) > theta.PQ_adhere)
+			{
+				PQ_effective = 0;
+			}
+
+			/////////////////////////////////////////////////////////////////////
+			// Is PQ metabolised?
+
 			if ((theta.PQ_CYP2D6_risk == 1) && (CYP2D6 == 1))
 			{
 				PQ_effective = 0;
@@ -1069,7 +1096,7 @@ void Individual::case_management(Params& theta)
 
 	/////////////////////////////////////////////////////////////////////
 	// Tafenoquine treatment regimen: blood-stage drugs and primaquine
-	// This is based on Narimane's primaquine treatment pathway.
+	// This is based on Narimane's tafenoquine treatment pathway.
 
 	if (theta.treat_regimen == 2)
 	{
@@ -1089,6 +1116,8 @@ void Individual::case_management(Params& theta)
 		I_LM_new  = 1;
 		I_D_new   = 1;
 
+		G6PD_test = 0;
+
 		T_last_BS = 0.0;
 
 
@@ -1112,10 +1141,18 @@ void Individual::case_management(Params& theta)
 					PQ_treat = 0;
 				}
 
+				//////////////////////////////////////////////////////////////////////////////////////////
+				// Is G6PD testing administered to those >6 months and not pregnant? If so, count test
+
+				if ((PQ_treat == 1) && (theta.TQ_PQ_G6PD_test == 1))
+				{
+					G6PD_test = 1;
+				}
+
 				/////////////////////////////////////////////////////////////////////
-				// Exclude PQ because of G6PD deficiency
+				// Exclude PQ because of G6PD deficiency if there is testing
 
-				if ((theta.PQ_G6PD_risk == 1) && (G6PD_activity < 4.0))
+				if ((theta.TQ_PQ_G6PD_test == 1) && (theta.PQ_G6PD_risk == 1) && (G6PD_activity < 4.0))
 				{
 					PQ_treat = 0;
 				}
@@ -1130,6 +1167,17 @@ void Individual::case_management(Params& theta)
 					PQ_effective = 1;
 				}
 
+				/////////////////////////////////////////////////////////////////////
+				// Is PQ adhered to?
+
+				if (genunf(0.0, 1.0) > theta.PQ_adhere)
+				{
+					PQ_effective = 0;
+				}
+
+				/////////////////////////////////////////////////////////////////////
+				// Is PQ metabolised?
+
 				if ((theta.PQ_CYP2D6_risk == 1) && (CYP2D6 == 1))
 				{
 					PQ_effective = 0;
@@ -1164,10 +1212,18 @@ void Individual::case_management(Params& theta)
 					TQ_treat = 0;
 				}
 
+				//////////////////////////////////////////////////////////////////////////////////////////
+				// Is G6PD testing is administered to those >16 years and not pregnant? If so, count test
+
+				if ((TQ_treat == 1) && (theta.TQ_G6PD_test == 1))
+				{
+					G6PD_test = 1;
+				}
+
 				/////////////////////////////////////////////////////////////////////
-				// Exclude TQ because of G6PD deficiency
+				// Exclude TQ because of G6PD deficiency if there is testing
 
-				if ((theta.TQ_G6PD_risk == 1) && (G6PD_activity < 7.0))
+				if ((theta.TQ_G6PD_test == 1) && (theta.TQ_G6PD_risk == 1) && (G6PD_activity < 7.0))
 				{
 					TQ_treat = 0;
 
@@ -1189,6 +1245,17 @@ void Individual::case_management(Params& theta)
 						TQ_effective = 1;
 					}
 
+					/////////////////////////////////////////////////////////////////////
+					// Is TQ adhered to?
+
+					if (genunf(0.0, 1.0) > theta.TQ_adhere)
+					{
+						TQ_effective = 0;
+					}
+
+					////////////////////////////////////////////////////////////////////
+					// Is TQ metabolised?
+					
 					if ((theta.TQ_CYP2D6_risk == 1) && (CYP2D6 == 1))
 					{
 						TQ_effective = 0;
@@ -1198,6 +1265,8 @@ void Individual::case_management(Params& theta)
 				/////////////////////////////////////////////////////////////////////
 				// Is PQ effective?
 
+				PQ_effective = 0;
+
 				if (PQ_treat == 1)
 				{
 					if (genunf(0.0, 1.0) < theta.PQ_PQeff)
@@ -1205,6 +1274,17 @@ void Individual::case_management(Params& theta)
 						PQ_effective = 1;
 					}
 
+					/////////////////////////////////////////////////////////////////////
+					// Is PQ adhered to?
+
+					if (genunf(0.0, 1.0) > theta.PQ_adhere)
+					{
+						PQ_effective = 0;
+					}
+
+					////////////////////////////////////////////////////////////////////
+					// Is PQ metabolised?
+
 					if ((theta.PQ_CYP2D6_risk == 1) && (CYP2D6 == 1))
 					{
 						PQ_effective = 0;
diff --git a/Pv_mod/Individual.h b/Pv_mod/Individual.h
index 682022ea8c5bde0b43011bde970ec51a2fcc26b0..87569bb21efb8757dead6cc4f79bf1c08f5252cd 100644
--- a/Pv_mod/Individual.h
+++ b/Pv_mod/Individual.h
@@ -137,6 +137,8 @@ public:
 	bool PQ_treat;          // Indicator for primaquine treatment
 	bool TQ_treat;          // Indicator for tafenoquine treatment
 
+	bool G6PD_test;			// New G6PD test administered
+
 	bool PQ_effective;     // Effective 8-aminoquinoline treatment (PQ)
 	bool PQ_overtreat;     // Over-treatment with 8-aminoquinolines (PQ) - defined as someone without hypnozoites being treated 
 	bool PQ_overtreat_9m;  // Over-treatment with 8-aminoquinolines (PQ) - defined as someone without BS infection in last 9 mths being treated
diff --git a/Pv_mod/Intervention.cpp b/Pv_mod/Intervention.cpp
index 01273a5398bcb11a83b4e03c40b86dd5333876a4..80b54cd8a6123bba16651cbd2a1ce930e3696632 100644
--- a/Pv_mod/Intervention.cpp
+++ b/Pv_mod/Intervention.cpp
@@ -103,7 +103,7 @@ Intervention::Intervention(const char *coverage_File)
 
 	vector<double> cov_read(N_cov_rounds + 1);
 
-	for (int i = 0; i < 107; i++)
+	for (int i = 0; i < 120; i++)
 	{
 		coverage_Stream2 >> discard;
 
@@ -148,10 +148,11 @@ Intervention::Intervention(const char *coverage_File)
 			PQ_PQproph.push_back(           coverage[8][j] );
 			PQ_avail.push_back(             coverage[9][j] );
 			PQ_adhere.push_back(            coverage[10][j] );
-			PQ_low_age.push_back(           coverage[11][j] );
-			PQ_G6PD_risk.push_back(   (int)(coverage[12][j]) );
-			PQ_CYP2D6_risk.push_back( (int)(coverage[13][j]) );
-			PQ_preg_risk.push_back(   (int)(coverage[14][j]) );
+			PQ_low_age.push_back(          (coverage[11][j]) );
+			PQ_G6PD_test.push_back(   (int)(coverage[12][j]) );
+			PQ_G6PD_risk.push_back(   (int)(coverage[13][j]) );
+			PQ_CYP2D6_risk.push_back( (int)(coverage[14][j]) );
+			PQ_preg_risk.push_back(   (int)(coverage[15][j]) );
 		}
 
 
@@ -161,18 +162,20 @@ Intervention::Intervention(const char *coverage_File)
 
 		if ((coverage[0][j] > -0.5) && (coverage[15][j] > -0.5))
 		{
-			TQ_year.push_back(              coverage[0][j]*365.0 );
-			TQ_cover.push_back(             coverage[15][j] );
-			TQ_BSeff.push_back(             coverage[16][j] );
-			TQ_BSproph.push_back(           coverage[17][j] );
-			TQ_TQeff.push_back(             coverage[18][j] );
-			TQ_TQproph.push_back(           coverage[19][j] );
-			TQ_avail.push_back(             coverage[20][j] );
-			TQ_adhere.push_back(            coverage[21][j] );
-			TQ_low_age.push_back(           coverage[22][j] );
-			TQ_G6PD_risk.push_back(   (int)(coverage[23][j]) );
-			TQ_CYP2D6_risk.push_back( (int)(coverage[24][j]) );
-			TQ_preg_risk.push_back(   (int)(coverage[25][j]) );
+			TQ_year.push_back(               coverage[0][j]*365.0 );
+			TQ_cover.push_back(              coverage[16][j] );
+			TQ_BSeff.push_back(              coverage[17][j] );
+			TQ_BSproph.push_back(            coverage[18][j] );
+			TQ_TQeff.push_back(              coverage[19][j] );
+			TQ_TQproph.push_back(            coverage[20][j] );
+			TQ_avail.push_back(              coverage[21][j] );
+			TQ_adhere.push_back(             coverage[22][j] );
+			TQ_low_age.push_back(           (coverage[23][j]) );
+			TQ_G6PD_test.push_back(    (int)(coverage[24][j]) );
+			TQ_PQ_G6PD_test.push_back( (int)(coverage[25][j]) );
+			TQ_G6PD_risk.push_back(    (int)(coverage[26][j]) );
+			TQ_CYP2D6_risk.push_back(  (int)(coverage[27][j]) );
+			TQ_preg_risk.push_back(    (int)(coverage[28][j]) );
 		}
 
 
@@ -180,10 +183,10 @@ Intervention::Intervention(const char *coverage_File)
 		// Intervention 3
 		// LLINs
 
-		if ((coverage[0][j] > -0.5) && (coverage[26][j] > -0.5))
+		if ((coverage[0][j] > -0.5) && (coverage[29][j] > -0.5))
 		{
 			LLIN_year.push_back(  coverage[0][j]*365.0 );
-			LLIN_cover.push_back( coverage[26][j] );
+			LLIN_cover.push_back( coverage[29][j] );
 		}
 
 
@@ -191,10 +194,10 @@ Intervention::Intervention(const char *coverage_File)
 		// Intervention 4
 		// IRS
 
-		if ((coverage[0][j] > -0.5) && (coverage[27][j] > -0.5))
+		if ((coverage[0][j] > -0.5) && (coverage[30][j] > -0.5))
 		{
 			IRS_year.push_back(  coverage[0][j]*365.0 );
-			IRS_cover.push_back( coverage[27][j] );
+			IRS_cover.push_back( coverage[30][j] );
 		}
 
 
@@ -202,12 +205,12 @@ Intervention::Intervention(const char *coverage_File)
 		// Intervention 5
 		// MDA - blood-stage drugs
 
-		if ((coverage[0][j] > -0.5) && (coverage[28][j] > -0.5))
+		if ((coverage[0][j] > -0.5) && (coverage[31][j] > -0.5))
 		{
 			MDA_BS_year.push_back(    coverage[0][j]*365.0 );
-			MDA_BS_cover.push_back(   coverage[28][j] );
-			MDA_BS_BSeff.push_back(   coverage[29][j] );
-			MDA_BS_BSproph.push_back( coverage[30][j] );
+			MDA_BS_cover.push_back(   coverage[31][j] );
+			MDA_BS_BSeff.push_back(   coverage[32][j] );
+			MDA_BS_BSproph.push_back( coverage[33][j] );
 		}
 
 
@@ -215,19 +218,20 @@ Intervention::Intervention(const char *coverage_File)
 		// Intervention 6
 		// MDA - blood-stage drugs plus primaquine
 
-		if ((coverage[0][j] > -0.5) && (coverage[31][j] > -0.5))
+		if ((coverage[0][j] > -0.5) && (coverage[34][j] > -0.5))
 		{
 			MDA_PQ_year.push_back(              coverage[0][j]*365.0 );
-			MDA_PQ_cover.push_back(             coverage[31][j] );
-			MDA_PQ_BSeff.push_back(             coverage[32][j] );
-			MDA_PQ_BSproph.push_back(           coverage[33][j] );
-			MDA_PQ_PQeff.push_back(             coverage[34][j] );
-			MDA_PQ_PQproph.push_back(           coverage[35][j] );
-			MDA_PQ_adhere.push_back(            coverage[36][j] );
-			MDA_PQ_low_age.push_back(           coverage[37][j] );
-			MDA_PQ_G6PD_risk.push_back(   (int)(coverage[38][j]) );
-			MDA_PQ_CYP2D6_risk.push_back( (int)(coverage[39][j]) );
-			MDA_PQ_preg_risk.push_back(   (int)(coverage[40][j]) );
+			MDA_PQ_cover.push_back(             coverage[34][j] );
+			MDA_PQ_BSeff.push_back(             coverage[35][j] );
+			MDA_PQ_BSproph.push_back(           coverage[36][j] );
+			MDA_PQ_PQeff.push_back(             coverage[37][j] );
+			MDA_PQ_PQproph.push_back(           coverage[38][j] );
+			MDA_PQ_adhere.push_back(            coverage[39][j] );
+			MDA_PQ_low_age.push_back(           coverage[40][j] );
+			MDA_PQ_G6PD_test.push_back(   (int)(coverage[41][j]) );
+			MDA_PQ_G6PD_risk.push_back(   (int)(coverage[42][j]) );
+			MDA_PQ_CYP2D6_risk.push_back( (int)(coverage[43][j]) );
+			MDA_PQ_preg_risk.push_back(   (int)(coverage[44][j]) );
 		}
 
 
@@ -235,19 +239,21 @@ Intervention::Intervention(const char *coverage_File)
 		// Intervention 7
 		// MDA - blood-stage drugs plus tafenoquine
 
-		if ((coverage[0][j] > -0.5) && (coverage[41][j] > -0.5))
+		if ((coverage[0][j] > -0.5) && (coverage[45][j] > -0.5))
 		{
-			MDA_TQ_year.push_back(              coverage[0][j]*365.0 );
-			MDA_TQ_cover.push_back(             coverage[41][j] );
-			MDA_TQ_BSeff.push_back(             coverage[42][j] );
-			MDA_TQ_BSproph.push_back(           coverage[43][j] );
-			MDA_TQ_TQeff.push_back(             coverage[44][j] );
-			MDA_TQ_TQproph.push_back(           coverage[45][j] );
-			MDA_TQ_adhere.push_back(            coverage[46][j] );
-			MDA_TQ_low_age.push_back(           coverage[47][j] );
-			MDA_TQ_G6PD_risk.push_back(   (int)(coverage[48][j]) );
-			MDA_TQ_CYP2D6_risk.push_back( (int)(coverage[49][j]) );
-			MDA_TQ_preg_risk.push_back(   (int)(coverage[50][j]) );
+			MDA_TQ_year.push_back(               coverage[0][j]*365.0 );
+			MDA_TQ_cover.push_back(              coverage[45][j] );
+			MDA_TQ_BSeff.push_back(              coverage[46][j] );
+			MDA_TQ_BSproph.push_back(            coverage[47][j] );
+			MDA_TQ_TQeff.push_back(              coverage[48][j] );
+			MDA_TQ_TQproph.push_back(            coverage[49][j] );
+			MDA_TQ_adhere.push_back(             coverage[50][j] );
+			MDA_TQ_low_age.push_back(            coverage[51][j] );
+			MDA_TQ_G6PD_test.push_back(    (int)(coverage[52][j]) );
+			MDA_TQ_PQ_G6PD_test.push_back( (int)(coverage[53][j]) );
+			MDA_TQ_G6PD_risk.push_back(    (int)(coverage[54][j]) );
+			MDA_TQ_CYP2D6_risk.push_back(  (int)(coverage[55][j]) );
+			MDA_TQ_preg_risk.push_back(    (int)(coverage[56][j]) );
 		}
 
 
@@ -255,14 +261,14 @@ Intervention::Intervention(const char *coverage_File)
 		// Intervention 8
 		// MSAT - blood-stage drugs only
 
-		if ((coverage[0][j] > -0.5) && (coverage[51][j] > -0.5))
+		if ((coverage[0][j] > -0.5) && (coverage[57][j] > -0.5))
 		{
 			MSAT_BS_year.push_back(    coverage[0][j]*365.0 );
-			MSAT_BS_cover.push_back(   coverage[51][j] );
-			MSAT_BS_RDT_PCR.push_back( coverage[52][j] );
-			MSAT_BS_sens.push_back(    coverage[53][j] );
-			MSAT_BS_BSeff.push_back(   coverage[54][j] );
-			MSAT_BS_BSproph.push_back( coverage[55][j] );
+			MSAT_BS_cover.push_back(   coverage[57][j] );
+			MSAT_BS_RDT_PCR.push_back( coverage[58][j] );
+			MSAT_BS_sens.push_back(    coverage[59][j] );
+			MSAT_BS_BSeff.push_back(   coverage[60][j] );
+			MSAT_BS_BSproph.push_back( coverage[61][j] );
 		}
 
 
@@ -270,21 +276,22 @@ Intervention::Intervention(const char *coverage_File)
 		// Intervention 9
 		// MSAT - blood-stage drugs plus primaquine
 
-		if ((coverage[0][j] > -0.5) && (coverage[56][j] > -0.5))
+		if ((coverage[0][j] > -0.5) && (coverage[62][j] > -0.5))
 		{
 			MSAT_PQ_year.push_back(              coverage[0][j]*365.0 );
-			MSAT_PQ_cover.push_back(             coverage[56][j] );
-			MSAT_PQ_RDT_PCR.push_back(           coverage[57][j] );
-			MSAT_PQ_sens.push_back(              coverage[58][j] );
-			MSAT_PQ_BSeff.push_back(             coverage[59][j] );
-			MSAT_PQ_BSproph.push_back(           coverage[60][j] );
-			MSAT_PQ_PQeff.push_back(             coverage[61][j] );
-			MSAT_PQ_PQproph.push_back(           coverage[62][j] );
-			MSAT_PQ_adhere.push_back(            coverage[63][j] );
-			MSAT_PQ_low_age.push_back(           coverage[64][j] );
-			MSAT_PQ_G6PD_risk.push_back(   (int)(coverage[65][j] ));
-			MSAT_PQ_CYP2D6_risk.push_back( (int)(coverage[66][j] ));
-			MSAT_PQ_preg_risk.push_back(   (int)(coverage[67][j] ));
+			MSAT_PQ_cover.push_back(             coverage[62][j] );
+			MSAT_PQ_RDT_PCR.push_back(           coverage[63][j] );
+			MSAT_PQ_sens.push_back(              coverage[64][j] );
+			MSAT_PQ_BSeff.push_back(             coverage[65][j] );
+			MSAT_PQ_BSproph.push_back(           coverage[66][j] );
+			MSAT_PQ_PQeff.push_back(             coverage[67][j] );
+			MSAT_PQ_PQproph.push_back(           coverage[68][j] );
+			MSAT_PQ_adhere.push_back(            coverage[69][j] );
+			MSAT_PQ_low_age.push_back(           coverage[70][j] );
+			MSAT_PQ_G6PD_test.push_back(   (int)(coverage[71][j] ));
+			MSAT_PQ_G6PD_risk.push_back(   (int)(coverage[72][j] ));
+			MSAT_PQ_CYP2D6_risk.push_back( (int)(coverage[73][j] ));
+			MSAT_PQ_preg_risk.push_back(   (int)(coverage[74][j] ));
 		}
 
 
@@ -292,21 +299,23 @@ Intervention::Intervention(const char *coverage_File)
 		// Intervention 10
 		// MSAT - blood-stage drugs plus tafenoquine
 
-		if ((coverage[0][j] > -0.5) && (coverage[68][j] > -0.5))
+		if ((coverage[0][j] > -0.5) && (coverage[75][j] > -0.5))
 		{
-			MSAT_TQ_year.push_back(              coverage[0][j]*365.0 );
-			MSAT_TQ_cover.push_back(             coverage[68][j] );
-			MSAT_TQ_RDT_PCR.push_back(           coverage[69][j] );
-			MSAT_TQ_sens.push_back(              coverage[70][j] );
-			MSAT_TQ_BSeff.push_back(             coverage[71][j] );
-			MSAT_TQ_BSproph.push_back(           coverage[72][j] );
-			MSAT_TQ_TQeff.push_back(             coverage[73][j] );
-			MSAT_TQ_TQproph.push_back(           coverage[74][j] );
-			MSAT_TQ_adhere.push_back(            coverage[75][j] );
-			MSAT_TQ_low_age.push_back(           coverage[76][j] );
-			MSAT_TQ_G6PD_risk.push_back(   (int)(coverage[77][j]) );
-			MSAT_TQ_CYP2D6_risk.push_back( (int)(coverage[78][j]) );
-			MSAT_TQ_preg_risk.push_back(   (int)(coverage[79][j]) );
+			MSAT_TQ_year.push_back(               coverage[0][j]*365.0 );
+			MSAT_TQ_cover.push_back(              coverage[75][j] );
+			MSAT_TQ_RDT_PCR.push_back(            coverage[76][j] );
+			MSAT_TQ_sens.push_back(               coverage[77][j] );
+			MSAT_TQ_BSeff.push_back(              coverage[78][j] );
+			MSAT_TQ_BSproph.push_back(            coverage[79][j] );
+			MSAT_TQ_TQeff.push_back(              coverage[80][j] );
+			MSAT_TQ_TQproph.push_back(            coverage[81][j] );
+			MSAT_TQ_adhere.push_back(             coverage[82][j] );
+			MSAT_TQ_low_age.push_back(            coverage[83][j] );
+			MSAT_TQ_G6PD_test.push_back(    (int)(coverage[84][j]) );
+			MSAT_TQ_PQ_G6PD_test.push_back( (int)(coverage[85][j]) );
+			MSAT_TQ_G6PD_risk.push_back(    (int)(coverage[86][j]) );
+			MSAT_TQ_CYP2D6_risk.push_back(  (int)(coverage[87][j]) );
+			MSAT_TQ_preg_risk.push_back(    (int)(coverage[88][j]) );
 		}
 
 
@@ -314,21 +323,22 @@ Intervention::Intervention(const char *coverage_File)
 		// Intervention 11
 		// STAT - blood-stage drugs plus primaquine
 
-		if ((coverage[0][j] > -0.5) && (coverage[80][j] > -0.5))
+		if ((coverage[0][j] > -0.5) && (coverage[89][j] > -0.5))
 		{
 			STAT_PQ_year.push_back(              coverage[0][j]*365.0 );
-			STAT_PQ_cover.push_back(             coverage[80][j] );
-			STAT_PQ_sens.push_back(              coverage[81][j] );
-			STAT_PQ_spec.push_back(              coverage[82][j] );
-			STAT_PQ_BSeff.push_back(             coverage[83][j] );
-			STAT_PQ_BSproph.push_back(           coverage[84][j] );
-			STAT_PQ_PQeff.push_back(             coverage[85][j] );
-			STAT_PQ_PQproph.push_back(           coverage[86][j] );
-			STAT_PQ_adhere.push_back(            coverage[87][j] );
-			STAT_PQ_low_age.push_back(           coverage[88][j] );
-			STAT_PQ_G6PD_risk.push_back(   (int)(coverage[89][j]) );
-			STAT_PQ_CYP2D6_risk.push_back( (int)(coverage[90][j]) );
-			STAT_PQ_preg_risk.push_back(   (int)(coverage[91][j]) );
+			STAT_PQ_cover.push_back(             coverage[89][j] );
+			STAT_PQ_sens.push_back(              coverage[90][j] );
+			STAT_PQ_spec.push_back(              coverage[91][j] );
+			STAT_PQ_BSeff.push_back(             coverage[92][j] );
+			STAT_PQ_BSproph.push_back(           coverage[93][j] );
+			STAT_PQ_PQeff.push_back(             coverage[94][j] );
+			STAT_PQ_PQproph.push_back(           coverage[95][j] );
+			STAT_PQ_adhere.push_back(            coverage[96][j] );
+			STAT_PQ_low_age.push_back(           coverage[97][j] );
+			STAT_PQ_G6PD_test.push_back(   (int)(coverage[98][j]) );
+			STAT_PQ_G6PD_risk.push_back(   (int)(coverage[99][j]) );
+			STAT_PQ_CYP2D6_risk.push_back( (int)(coverage[100][j]) );
+			STAT_PQ_preg_risk.push_back(   (int)(coverage[101][j]) );
 		}
 
 
@@ -336,21 +346,23 @@ Intervention::Intervention(const char *coverage_File)
 		// Intervention 12
 		// STAT - blood-stage drugs plus tafenoquine
 
-		if ((coverage[0][j] > -0.5) && (coverage[92][j] > -0.5))
+		if ((coverage[0][j] > -0.5) && (coverage[102][j] > -0.5))
 		{
-			STAT_TQ_year.push_back(              coverage[0][j]*365.0 );
-			STAT_TQ_cover.push_back(             coverage[92][j] );
-			STAT_TQ_sens.push_back(              coverage[93][j] );
-			STAT_TQ_spec.push_back(              coverage[94][j] );
-			STAT_TQ_BSeff.push_back(             coverage[95][j] );
-			STAT_TQ_BSproph.push_back(           coverage[96][j] );
-			STAT_TQ_TQeff.push_back(             coverage[97][j] );
-			STAT_TQ_TQproph.push_back(           coverage[98][j] );
-			STAT_TQ_adhere.push_back(            coverage[99][j] );
-			STAT_TQ_low_age.push_back(           coverage[100][j] );
-			STAT_TQ_G6PD_risk.push_back(   (int)(coverage[101][j]) );
-			STAT_TQ_CYP2D6_risk.push_back( (int)(coverage[102][j]) );
-			STAT_TQ_preg_risk.push_back(   (int)(coverage[103][j]) );
+			STAT_TQ_year.push_back(               coverage[0][j]*365.0 );
+			STAT_TQ_cover.push_back(              coverage[102][j] );
+			STAT_TQ_sens.push_back(               coverage[103][j] );
+			STAT_TQ_spec.push_back(               coverage[104][j] );
+			STAT_TQ_BSeff.push_back(              coverage[105][j] );
+			STAT_TQ_BSproph.push_back(            coverage[106][j] );
+			STAT_TQ_TQeff.push_back(              coverage[107][j] );
+			STAT_TQ_TQproph.push_back(            coverage[108][j] );
+			STAT_TQ_adhere.push_back(             coverage[109][j] );
+			STAT_TQ_low_age.push_back(            coverage[110][j] );
+			STAT_TQ_G6PD_test.push_back(    (int)(coverage[111][j]) );
+			STAT_TQ_PQ_G6PD_test.push_back( (int)(coverage[112][j]) );
+			STAT_TQ_G6PD_risk.push_back(    (int)(coverage[113][j]) );
+			STAT_TQ_CYP2D6_risk.push_back(  (int)(coverage[114][j]) );
+			STAT_TQ_preg_risk.push_back(    (int)(coverage[115][j]) );
 		}
 
 
@@ -358,12 +370,12 @@ Intervention::Intervention(const char *coverage_File)
 		// Intervention 13
 		// IVM
 
-		if ((coverage[0][j] > -0.5) && (coverage[104][j] > -0.5))
+		if ((coverage[0][j] > -0.5) && (coverage[116][j] > -0.5))
 		{
 			IVM_year.push_back(      coverage[0][j]*365.0 );
-			IVM_cover.push_back(     coverage[104][j] );
-			d_IVM_0.push_back(       coverage[105][j] );
-			IVM_half_life.push_back( coverage[106][j] );
+			IVM_cover.push_back(     coverage[117][j] );
+			d_IVM_0.push_back(       coverage[118][j] );
+			IVM_half_life.push_back( coverage[119][j] );
 		}
 	}
 
@@ -384,6 +396,8 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 	bool PQ_treat;
 	bool TQ_treat;
 
+	bool G6PD_test;
+
 	bool BS_effective;
 	bool PQ_effective;
 	bool TQ_effective;
@@ -435,6 +449,7 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 			theta.PQ_avail       = PQ_avail[m];
 			theta.PQ_adhere      = PQ_adhere[m];
 			theta.PQ_low_age     = PQ_low_age[m];
+			theta.PQ_G6PD_test   = PQ_G6PD_test[m];
 			theta.PQ_G6PD_risk   = PQ_G6PD_risk[m];
 			theta.PQ_CYP2D6_risk = PQ_CYP2D6_risk[m];
 			theta.PQ_preg_risk   = PQ_preg_risk[m];
@@ -458,17 +473,19 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 
 			theta.treat_regimen = 2;
 
-			theta.treat_cover    = TQ_cover[m];
-			theta.TQ_BSeff       = TQ_BSeff[m];
-			theta.TQ_BSproph     = TQ_BSproph[m];
-			theta.TQ_TQeff       = TQ_TQeff[m];
-			theta.TQ_TQproph     = TQ_TQproph[m];
-			theta.TQ_avail       = TQ_avail[m];
-			theta.TQ_adhere      = TQ_adhere[m];
-			theta.TQ_low_age     = TQ_low_age[m];
-			theta.TQ_G6PD_risk   = TQ_G6PD_risk[m];
-			theta.TQ_CYP2D6_risk = TQ_CYP2D6_risk[m];
-			theta.TQ_preg_risk   = TQ_preg_risk[m];
+			theta.treat_cover     = TQ_cover[m];
+			theta.TQ_BSeff        = TQ_BSeff[m];
+			theta.TQ_BSproph      = TQ_BSproph[m];
+			theta.TQ_TQeff        = TQ_TQeff[m];
+			theta.TQ_TQproph      = TQ_TQproph[m];
+			theta.TQ_avail        = TQ_avail[m];
+			theta.TQ_adhere       = TQ_adhere[m];
+			theta.TQ_low_age      = TQ_low_age[m];
+			theta.TQ_G6PD_test    = TQ_G6PD_test[m];
+			theta.TQ_PQ_G6PD_test = TQ_PQ_G6PD_test[m];
+			theta.TQ_G6PD_risk    = TQ_G6PD_risk[m];
+			theta.TQ_CYP2D6_risk  = TQ_CYP2D6_risk[m];
+			theta.TQ_preg_risk    = TQ_preg_risk[m];
 
 			theta.treat_cov_eff = TQ_cover[m]*TQ_BSeff[m];
 
@@ -634,6 +651,8 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 			theta.MDA_PQ_BSproph     = MDA_PQ_BSproph[m];
 			theta.MDA_PQ_PQeff       = MDA_PQ_PQeff[m];
 			theta.MDA_PQ_PQproph     = MDA_PQ_PQproph[m];
+			theta.MDA_PQ_adhere		 = MDA_PQ_adhere[m];
+			theta.MDA_PQ_G6PD_test   = MDA_PQ_G6PD_test[m];
 			theta.MDA_PQ_G6PD_risk   = MDA_PQ_G6PD_risk[m];
 			theta.MDA_PQ_CYP2D6_risk = MDA_PQ_CYP2D6_risk[m];
 			theta.MDA_PQ_preg_risk   = MDA_PQ_preg_risk[m];
@@ -674,16 +693,17 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 					// Is PQ administered?
 
 					PQ_treat = 1;
+					G6PD_test = 0;
 
 
 					/////////////////////////////////////////////////////////////////////
-					// Exclude PQ because of G6PD deficiency
+					// Exclude PQ because of young age
 
-					if ((theta.MDA_PQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 4.0))
+					if (POP.people[n].age < theta.MDA_PQ_low_age)
 					{
 						PQ_treat = 0;
 					}
-
+					
 
 					/////////////////////////////////////////////////////////////////////
 					// Exclude PQ because of pregancy
@@ -694,14 +714,23 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 					}
 
 
+					//////////////////////////////////////////////////////////////////////////////////////////
+					// Is G6PD testing administered ? If so, count test
+
+					if ((PQ_treat == 1) && (theta.MDA_PQ_G6PD_test == 1))
+					{
+						G6PD_test = 1;
+					}
+
+
 					/////////////////////////////////////////////////////////////////////
-					// Exclude PQ because of young age
+					// Exclude PQ because of G6PD deficiency if there is testing
 
-					if (POP.people[n].age < theta.MDA_PQ_low_age)
+					if ((theta.MDA_PQ_G6PD_test == 1) && (theta.MDA_PQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 4.0))
 					{
 						PQ_treat = 0;
 					}
-					
+
 
 					/////////////////////////////////////////////////////////////////////
 					// Is PQ effective?
@@ -713,6 +742,19 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 						PQ_effective = 0;
 					}
 
+
+					/////////////////////////////////////////////////////////////////////
+					// Is PQ adhered to?
+
+					if (genunf(0.0, 1.0) > theta.MDA_PQ_adhere)
+					{
+						PQ_effective = 0;
+					}
+
+
+					/////////////////////////////////////////////////////////////////////
+					// Is PQ metabolised?
+
 					if ((theta.MDA_PQ_CYP2D6_risk == 1) && (POP.people[n].CYP2D6 == 1))
 					{
 						PQ_effective = 0;
@@ -758,6 +800,14 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 						POP.people[n].PQ_treat = 0;
 					}
 
+					if (G6PD_test == 1)
+					{
+						POP.people[n].G6PD_test = 1;
+					}
+					else {
+						POP.people[n].G6PD_test = 0;
+					}
+
 					if ((PQ_treat == 1) && (PQ_effective == 1))
 					{
 						POP.people[n].Hyp = 0;
@@ -784,15 +834,18 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 			////////////////////////////////////////////
 			// Update parameters
 
-			theta.MDA_TQ_cover       = MDA_TQ_cover[m];
-			theta.MDA_TQ_BSeff       = MDA_TQ_BSeff[m];
-			theta.MDA_TQ_BSproph     = MDA_TQ_BSproph[m];
-			theta.MDA_TQ_TQeff       = MDA_TQ_TQeff[m];
-			theta.MDA_TQ_TQproph     = MDA_TQ_TQproph[m];
-			theta.MDA_TQ_G6PD_risk   = MDA_TQ_G6PD_risk[m];
-			theta.MDA_TQ_CYP2D6_risk = MDA_TQ_CYP2D6_risk[m];
-			theta.MDA_TQ_preg_risk   = MDA_TQ_preg_risk[m];
-			theta.MDA_TQ_low_age     = MDA_TQ_low_age[m];
+			theta.MDA_TQ_cover          = MDA_TQ_cover[m];
+			theta.MDA_TQ_BSeff          = MDA_TQ_BSeff[m];
+			theta.MDA_TQ_BSproph        = MDA_TQ_BSproph[m];
+			theta.MDA_TQ_TQeff          = MDA_TQ_TQeff[m];
+			theta.MDA_TQ_TQproph        = MDA_TQ_TQproph[m];
+			theta.MDA_TQ_adhere         = MDA_TQ_adhere[m];
+			theta.MDA_TQ_G6PD_test		= MDA_TQ_G6PD_test[m];
+			theta.MDA_TQ_PQ_G6PD_test   = MDA_TQ_PQ_G6PD_test[m];
+			theta.MDA_TQ_G6PD_risk      = MDA_TQ_G6PD_risk[m];
+			theta.MDA_TQ_CYP2D6_risk    = MDA_TQ_CYP2D6_risk[m];
+			theta.MDA_TQ_preg_risk      = MDA_TQ_preg_risk[m];
+			theta.MDA_TQ_low_age        = MDA_TQ_low_age[m];
 
 
 			////////////////////////////////////////////
@@ -832,6 +885,8 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 					{
 						PQ_treat = 1;
 						TQ_treat = 0;
+						G6PD_test = 0;
+
 
 						/////////////////////////////////////////////////////////////////////
 						// Exclude PQ because of pregancy
@@ -841,14 +896,25 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 							PQ_treat = 0;
 						}
 
+
+						//////////////////////////////////////////////////////////////////////////////////////////
+						// Is G6PD testing administered ? If so, count test
+
+						if ((PQ_treat == 1) && (theta.MDA_TQ_PQ_G6PD_test == 1))
+						{
+							G6PD_test = 1;
+						}
+
+
 						/////////////////////////////////////////////////////////////////////
-						// Exclude PQ because of G6PD deficiency
+						// Exclude PQ because of G6PD deficiency if there is testing
 
-						if ((theta.MDA_PQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 4.0))
+						if ((theta.MDA_TQ_PQ_G6PD_test == 1) && (theta.MDA_PQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 4.0))
 						{
 							PQ_treat = 0;
 						}
 
+
 						/////////////////////////////////////////////////////////////////////
 						// Is PQ effective?
 
@@ -859,6 +925,18 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 							PQ_effective = 0;
 						}
 
+						
+						/////////////////////////////////////////////////////////////////////
+						// Is PQ adhered to?
+
+						if (genunf(0.0, 1.0) > theta.MDA_PQ_adhere)
+						{
+							PQ_effective = 0;
+						}
+
+						/////////////////////////////////////////////////////////////////////
+						// Is PQ metabolised?
+
 						if ((theta.MDA_PQ_CYP2D6_risk == 1) && (POP.people[n].CYP2D6 == 1))
 						{
 							PQ_effective = 0;
@@ -904,6 +982,14 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 							POP.people[n].PQ_treat = 0;
 						}
 
+						if (G6PD_test == 1)
+						{
+							POP.people[n].G6PD_test = 1;
+						}
+						else {
+							POP.people[n].G6PD_test = 0;
+						}
+
 						if ((PQ_treat == 1) && (PQ_effective == 1))
 						{
 							POP.people[n].Hyp = 0;
@@ -921,6 +1007,8 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 					{
 						TQ_treat = 1;
 						PQ_treat = 0;
+						G6PD_test = 0;
+
 
 						/////////////////////////////////////////////////////////////////////
 						// Exclude TQ because of pregancy
@@ -930,10 +1018,18 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 							TQ_treat = 0;
 						}
 
+						//////////////////////////////////////////////////////////////////////////////////////////
+						// Is G6PD testing administered to those >16 years and not pregnant? If so, count test
+
+						if ((TQ_treat == 1) && (theta.MDA_TQ_G6PD_test == 1))
+						{
+							G6PD_test = 1;
+						}
+
 						/////////////////////////////////////////////////////////////////////
-						// Exclude TQ because of G6PD deficiency
+						// Exclude TQ because of G6PD deficiency if there is testing
 
-						if ((theta.MDA_TQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 7.0))
+						if ((theta.MDA_TQ_G6PD_test == 1) && (theta.MDA_TQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 7.0))
 						{
 							TQ_treat = 0;
 
@@ -955,6 +1051,17 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 								TQ_effective = 1;
 							}
 
+							/////////////////////////////////////////////////////////////////////
+							// Is TQ adhered to?
+
+							if (genunf(0.0, 1.0) > theta.MDA_TQ_adhere)
+							{
+								TQ_effective = 0;
+							}
+
+							/////////////////////////////////////////////////////////////////////
+							// Is TQ metabolised?
+
 							if ((theta.MDA_TQ_CYP2D6_risk == 1) && (POP.people[n].CYP2D6 == 1))
 							{
 								TQ_effective = 0;
@@ -971,6 +1078,17 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 								PQ_effective = 1;
 							}
 
+							/////////////////////////////////////////////////////////////////////
+							// Is PQ adhered to?
+
+							if (genunf(0.0, 1.0) > theta.MDA_PQ_adhere)
+							{
+								PQ_effective = 0;
+							}
+
+							/////////////////////////////////////////////////////////////////////
+							// Is PQ metabolised?
+
 							if ((theta.MDA_PQ_CYP2D6_risk == 1) && (POP.people[n].CYP2D6 == 1))
 							{
 								PQ_effective = 0;
@@ -1031,6 +1149,14 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 							POP.people[n].PQ_treat = 0;
 						}
 
+						if (G6PD_test == 1)
+						{
+							POP.people[n].G6PD_test = 1;
+						}
+						else {
+							POP.people[n].G6PD_test = 0;
+						}
+
 						if ((PQ_treat == 1) && (PQ_effective == 1))
 						{
 							POP.people[n].Hyp = 0;
@@ -1051,6 +1177,14 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 							POP.people[n].TQ_treat = 0;
 						}
 
+						if (G6PD_test == 1)
+						{
+							POP.people[n].G6PD_test = 1;
+						}
+						else {
+							POP.people[n].G6PD_test = 0;
+						}
+
 						if ((TQ_treat == 1) && (TQ_effective == 1))
 						{
 							POP.people[n].Hyp = 0;
@@ -1191,6 +1325,8 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 			theta.MSAT_PQ_BSproph     = MSAT_PQ_BSproph[m];
 			theta.MSAT_PQ_PQeff       = MSAT_PQ_PQeff[m];
 			theta.MSAT_PQ_PQproph     = MSAT_PQ_PQproph[m];
+			theta.MSAT_PQ_adhere	  = MSAT_PQ_adhere[m];
+			theta.MSAT_PQ_G6PD_test   = MSAT_PQ_G6PD_test[m];
 			theta.MSAT_PQ_G6PD_risk   = MSAT_PQ_G6PD_risk[m];
 			theta.MSAT_PQ_CYP2D6_risk = MSAT_PQ_CYP2D6_risk[m];
 			theta.MSAT_PQ_preg_risk   = MSAT_PQ_preg_risk[m];
@@ -1266,12 +1402,13 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 						// Is PQ administered?
 
 						PQ_treat = 1;
+						G6PD_test = 0;
 
 
 						/////////////////////////////////////////////////////////////////////
-						// Exclude PQ because of G6PD deficiency
+						// Exclude PQ because of young age
 
-						if ((theta.MSAT_PQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 4.0))
+						if (POP.people[n].age < theta.MSAT_PQ_low_age)
 						{
 							PQ_treat = 0;
 						}
@@ -1284,17 +1421,20 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 							PQ_treat = 0;
 						}
 
-						/////////////////////////////////////////////////////////////////////
-						// Exclude PQ because of young age
+						//////////////////////////////////////////////////////////////////////////////////////////
+						// Is G6PD testing administered ? If so, count test
 
-						if (POP.people[n].age < theta.MSAT_PQ_low_age)
+						if ((PQ_treat == 1) && (theta.MSAT_PQ_G6PD_test == 1))
 						{
-							PQ_treat = 0;
+							G6PD_test = 1;
 						}
 
-						if (PQ_treat == 1)
+						/////////////////////////////////////////////////////////////////////
+						// Exclude PQ because of G6PD deficiency if there is testing
+
+						if ((theta.MSAT_PQ_G6PD_test == 1) && (theta.MSAT_PQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 4.0))
 						{
-							POP.people[n].PQ_treat = 1;
+							PQ_treat = 0;
 						}
 
 						/////////////////////////////////////////////////////////////////////
@@ -1307,6 +1447,17 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 							PQ_effective = 0;
 						}
 
+						/////////////////////////////////////////////////////////////////////
+						// Is PQ adhered to?
+
+						if (genunf(0.0, 1.0) > theta.MSAT_PQ_adhere)
+						{
+							PQ_effective = 0;
+						}
+
+						/////////////////////////////////////////////////////////////////////
+						// Is PQ metabolised?
+
 						if ((theta.MSAT_PQ_CYP2D6_risk == 1) && (POP.people[n].CYP2D6 == 1))
 						{
 							PQ_effective = 0;
@@ -1352,6 +1503,14 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 							POP.people[n].PQ_treat = 0;
 						}
 
+						if (G6PD_test == 1)
+						{
+							POP.people[n].G6PD_test = 1;
+						}
+						else {
+							POP.people[n].G6PD_test = 0;
+						}
+
 						if ((PQ_treat == 1) && (PQ_effective == 1))
 						{
 							POP.people[n].Hyp = 0;
@@ -1380,17 +1539,20 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 			////////////////////////////////////////////
 			// Update parameters
 
-			theta.MSAT_TQ_cover       = MSAT_TQ_cover[m];
-			theta.MSAT_TQ_RDT_PCR     = MSAT_TQ_RDT_PCR[m];
-			theta.MSAT_TQ_sens        = MSAT_TQ_sens[m];
-			theta.MSAT_TQ_BSeff       = MSAT_TQ_BSeff[m];
-			theta.MSAT_TQ_BSproph     = MSAT_TQ_BSproph[m];
-			theta.MSAT_TQ_TQeff       = MSAT_TQ_TQeff[m];
-			theta.MSAT_TQ_TQproph     = MSAT_TQ_TQproph[m];
-			theta.MSAT_TQ_G6PD_risk   = MSAT_TQ_G6PD_risk[m];
-			theta.MSAT_TQ_CYP2D6_risk = MSAT_TQ_CYP2D6_risk[m];
-			theta.MSAT_TQ_preg_risk   = MSAT_TQ_preg_risk[m];
-			theta.MSAT_TQ_low_age     = MSAT_TQ_low_age[m];
+			theta.MSAT_TQ_cover        = MSAT_TQ_cover[m];
+			theta.MSAT_TQ_RDT_PCR      = MSAT_TQ_RDT_PCR[m];
+			theta.MSAT_TQ_sens         = MSAT_TQ_sens[m];
+			theta.MSAT_TQ_BSeff        = MSAT_TQ_BSeff[m];
+			theta.MSAT_TQ_BSproph      = MSAT_TQ_BSproph[m];
+			theta.MSAT_TQ_TQeff        = MSAT_TQ_TQeff[m];
+			theta.MSAT_TQ_TQproph      = MSAT_TQ_TQproph[m];
+			theta.MSAT_TQ_adhere       = MSAT_TQ_adhere[m];
+			theta.MSAT_TQ_G6PD_test    = MSAT_TQ_G6PD_test[m];
+			theta.MSAT_TQ_PQ_G6PD_test = MSAT_TQ_PQ_G6PD_test[m];
+			theta.MSAT_TQ_G6PD_risk    = MSAT_TQ_G6PD_risk[m];
+			theta.MSAT_TQ_CYP2D6_risk  = MSAT_TQ_CYP2D6_risk[m];
+			theta.MSAT_TQ_preg_risk    = MSAT_TQ_preg_risk[m];
+			theta.MSAT_TQ_low_age      = MSAT_TQ_low_age[m];
 
 
 			////////////////////////////////////////////
@@ -1450,6 +1612,7 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 					{
 						PQ_treat = 0;
 						TQ_treat = 0;
+						G6PD_test = 0;
 
 
 						/////////////////////////////////////////////////////
@@ -1478,10 +1641,18 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 								PQ_treat = 0;
 							}
 
+							//////////////////////////////////////////////////////////////////////////////////////////
+							// Is G6PD testing administered ? If so, count test
+
+							if ((PQ_treat == 1) && (theta.MSAT_TQ_PQ_G6PD_test == 1))
+							{
+								G6PD_test = 1;
+							}
+
 							/////////////////////////////////////////////////////////////////////
-							// Exclude PQ because of G6PD deficiency
+							// Exclude PQ because of G6PD deficiency if tested
 
-							if ((theta.MSAT_PQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 4.0))
+							if ((theta.MSAT_TQ_PQ_G6PD_test == 1) && (theta.MSAT_PQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 4.0))
 							{
 								PQ_treat = 0;
 							}
@@ -1496,6 +1667,17 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 								PQ_effective = 1;
 							}
 
+							/////////////////////////////////////////////////////////////////////
+							// Is PQ adhered to?
+
+							if (genunf(0.0, 1.0) > theta.MSAT_PQ_adhere)
+							{
+								PQ_effective = 0;
+							}
+
+							/////////////////////////////////////////////////////////////////////
+							// Is PQ metabolised?
+
 							if ((theta.MSAT_PQ_CYP2D6_risk == 1) && (POP.people[n].CYP2D6 == 1))
 							{
 								PQ_effective = 0;
@@ -1549,6 +1731,14 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 								POP.people[n].PQ_treat = 0;
 							}
 
+							if (G6PD_test == 1)
+							{
+								POP.people[n].G6PD_test = 1;
+							}
+							else {
+								POP.people[n].G6PD_test = 0;
+							}
+
 							if ((PQ_treat == 1) && (PQ_effective == 1))
 							{
 								POP.people[n].Hyp = 0;
@@ -1566,6 +1756,8 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 						{
 							TQ_treat = 1;
 							PQ_treat = 0;
+							G6PD_test = 0;
+
 
 							/////////////////////////////////////////////////////////////////////
 							// Exclude TQ because of pregancy
@@ -1575,10 +1767,18 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 								TQ_treat = 0;
 							}
 
+							//////////////////////////////////////////////////////////////////////////////////////////
+							// Is G6PD testing administered to those >16 years and not pregnant? If so, count test
+
+							if ((TQ_treat == 1) && (theta.MSAT_TQ_G6PD_test == 1))
+							{
+								G6PD_test = 1;
+							}
+
 							/////////////////////////////////////////////////////////////////////
-							// Exclude TQ because of G6PD deficiency
+							// Exclude TQ because of G6PD deficiency if there is testing
 
-							if ((theta.MSAT_TQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 7.0))
+							if ((theta.MSAT_TQ_G6PD_test == 1) && (theta.MSAT_TQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 7.0))
 							{
 								TQ_treat = 0;
 
@@ -1600,6 +1800,17 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 									TQ_effective = 1;
 								}
 
+								/////////////////////////////////////////////////////////////////////
+								// Is TQ adhered to?
+
+								if (genunf(0.0, 1.0) > theta.MSAT_TQ_adhere)
+								{
+									TQ_effective = 0;
+								}
+
+								/////////////////////////////////////////////////////////////////////
+								// Is TQ metabolised?
+
 								if ((theta.MSAT_TQ_CYP2D6_risk == 1) && (POP.people[n].CYP2D6 == 1))
 								{
 									TQ_effective = 0;
@@ -1613,6 +1824,16 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 									PQ_effective = 1;
 								}
 
+								/////////////////////////////////////////////////////////////////////
+								// Is PQ adhered to?
+
+								if (genunf(0.0, 1.0) > theta.MSAT_PQ_adhere)
+								{
+									PQ_effective = 0;
+								}
+
+								/////////////////////////////////////////////////////////////////////
+								// Is PQ metabolised?
 								if ((theta.MSAT_TQ_CYP2D6_risk == 1) && (POP.people[n].CYP2D6 == 1))
 								{
 									PQ_effective = 0;
@@ -1660,6 +1881,13 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 								if (POP.people[n].I_D   == 1) { POP.people[n].I_D = 0;   POP.people[n].T = 1; }
 							}
 
+							if (G6PD_test == 1)
+							{
+								POP.people[n].G6PD_test = 1;
+							}
+							else {
+								POP.people[n].G6PD_test = 0;
+							}
 
 							/////////////////////////////////////////////////////////////////////
 							// ACTION: administer primaquine
@@ -1729,6 +1957,8 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 			theta.STAT_PQ_BSproph     = STAT_PQ_BSproph[m];
 			theta.STAT_PQ_PQeff       = STAT_PQ_PQeff[m];
 			theta.STAT_PQ_PQproph     = STAT_PQ_PQproph[m];
+			theta.STAT_PQ_adhere      = STAT_PQ_adhere[m];
+			theta.STAT_PQ_G6PD_test   = STAT_PQ_G6PD_test[m];
 			theta.STAT_PQ_G6PD_risk   = STAT_PQ_G6PD_risk[m];
 			theta.STAT_PQ_CYP2D6_risk = STAT_PQ_CYP2D6_risk[m];
 			theta.STAT_PQ_preg_risk   = STAT_PQ_preg_risk[m];
@@ -1812,16 +2042,18 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 						// Is PQ administered?
 
 						PQ_treat = 0;
+						G6PD_test = 0;
 
 						if (STAT_pos == 1)
 						{
 							PQ_treat = 1;
 						}
 
+
 						/////////////////////////////////////////////////////////////////////
-						// Exclude PQ because of G6PD deficiency
+						// Exclude PQ because of young age
 
-						if ((theta.STAT_PQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 4.0))
+						if (POP.people[n].age < theta.STAT_PQ_low_age)
 						{
 							PQ_treat = 0;
 						}
@@ -1834,15 +2066,23 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 							PQ_treat = 0;
 						}
 
+						//////////////////////////////////////////////////////////////////////////////////////////
+						// Is G6PD testing administered to those >6 months and not pregnant? If so, count test
+
+						if ((PQ_treat == 1) && (theta.STAT_PQ_G6PD_test == 1))
+						{
+							G6PD_test = 1;
+						}
+
 						/////////////////////////////////////////////////////////////////////
-						// Exclude PQ because of young age
+						// Exclude PQ because of G6PD deficiency if there is testing
 
-						if (POP.people[n].age < theta.STAT_PQ_low_age)
+						if ((theta.STAT_PQ_G6PD_test == 1) && (theta.STAT_PQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 4.0))
 						{
 							PQ_treat = 0;
 						}
 
-
+						
 						/////////////////////////////////////////////////////////////////////
 						// Is PQ effective?
 
@@ -1853,6 +2093,17 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 							PQ_effective = 1;
 						}
 
+						/////////////////////////////////////////////////////////////////////
+						// Is PQ adhered to?
+
+						if (genunf(0.0, 1.0) > theta.STAT_PQ_adhere)
+						{
+							PQ_effective = 0;
+						}
+
+						/////////////////////////////////////////////////////////////////////
+						// Is PQ metabolised?
+
 						if ((theta.STAT_PQ_CYP2D6_risk == 1) && (POP.people[n].CYP2D6 == 1))
 						{
 							PQ_effective = 0;
@@ -1898,6 +2149,14 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 							POP.people[n].PQ_treat = 0;
 						}
 
+						if (G6PD_test == 1)
+						{
+							POP.people[n].G6PD_test = 1;
+						}
+						else {
+							POP.people[n].G6PD_test = 0;
+						}
+
 						if ((PQ_treat == 1) && (PQ_effective == 1))
 						{
 							POP.people[n].Hyp = 0;
@@ -1925,17 +2184,20 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 			////////////////////////////////////////////
 			// Update parameters
 
-			theta.STAT_TQ_cover       = STAT_TQ_cover[m];
-			theta.STAT_TQ_sens        = STAT_TQ_sens[m];
-			theta.STAT_TQ_spec        = STAT_TQ_spec[m];
-			theta.STAT_TQ_BSeff       = STAT_TQ_BSeff[m];
-			theta.STAT_TQ_BSproph     = STAT_TQ_BSproph[m];
-			theta.STAT_TQ_TQeff       = STAT_TQ_TQeff[m];
-			theta.STAT_TQ_TQproph     = STAT_TQ_TQproph[m];
-			theta.STAT_TQ_G6PD_risk   = STAT_TQ_G6PD_risk[m];
-			theta.STAT_TQ_CYP2D6_risk = STAT_TQ_CYP2D6_risk[m];
-			theta.STAT_TQ_preg_risk   = STAT_TQ_preg_risk[m];
-			theta.STAT_TQ_low_age     = STAT_TQ_low_age[m];
+			theta.STAT_TQ_cover        = STAT_TQ_cover[m];
+			theta.STAT_TQ_sens         = STAT_TQ_sens[m];
+			theta.STAT_TQ_spec         = STAT_TQ_spec[m];
+			theta.STAT_TQ_BSeff        = STAT_TQ_BSeff[m];
+			theta.STAT_TQ_BSproph      = STAT_TQ_BSproph[m];
+			theta.STAT_TQ_TQeff        = STAT_TQ_TQeff[m];
+			theta.STAT_TQ_TQproph      = STAT_TQ_TQproph[m];
+			theta.STAT_TQ_adhere       = STAT_TQ_adhere[m];
+			theta.STAT_TQ_G6PD_test    = STAT_TQ_G6PD_test[m];
+			theta.STAT_TQ_PQ_G6PD_test = STAT_TQ_PQ_G6PD_test[m];
+			theta.STAT_TQ_G6PD_risk    = STAT_TQ_G6PD_risk[m];
+			theta.STAT_TQ_CYP2D6_risk  = STAT_TQ_CYP2D6_risk[m];
+			theta.STAT_TQ_preg_risk    = STAT_TQ_preg_risk[m];
+			theta.STAT_TQ_low_age      = STAT_TQ_low_age[m];
 
 
 			////////////////////////////////////////////
@@ -2004,6 +2266,8 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 					{
 						PQ_treat = 0;
 						TQ_treat = 0;
+						G6PD_test = 0;
+
 
 						/////////////////////////////////////////////////////
 						// Is blood-stage treatment effective
@@ -2030,10 +2294,18 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 								PQ_treat = 0;
 							}
 
+							//////////////////////////////////////////////////////////////////////////////////////////
+							// Is G6PD testing administered ? If so, count test
+
+							if ((PQ_treat == 1) && (theta.STAT_TQ_PQ_G6PD_test == 1))
+							{
+								G6PD_test = 1;
+							}
+
 							/////////////////////////////////////////////////////////////////////
-							// Exclude PQ because of G6PD deficiency
+							// Exclude PQ because of G6PD deficiency if there is testing
 
-							if ((theta.STAT_PQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 4.0))
+							if ((theta.STAT_TQ_PQ_G6PD_test == 1) && (theta.STAT_PQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 4.0))
 							{
 								PQ_treat = 0;
 							}
@@ -2048,6 +2320,17 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 								PQ_effective = 1;
 							}
 
+							/////////////////////////////////////////////////////////////////////
+							// Is PQ adhered to?
+
+							if (genunf(0.0, 1.0) > theta.STAT_PQ_adhere)
+							{
+								PQ_effective = 0;
+							}
+
+							/////////////////////////////////////////////////////////////////////
+							// Is PQ metabolised?
+
 							if ((theta.STAT_PQ_CYP2D6_risk == 1) && (POP.people[n].CYP2D6 == 1))
 							{
 								PQ_effective = 0;
@@ -2092,6 +2375,14 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 								POP.people[n].PQ_treat = 0;
 							}
 
+							if (G6PD_test == 1)
+							{
+								POP.people[n].G6PD_test = 1;
+							}
+							else {
+								POP.people[n].G6PD_test = 0;
+							}
+
 							if ((PQ_treat == 1) && (PQ_effective == 1))
 							{
 								POP.people[n].Hyp = 0;
@@ -2109,6 +2400,8 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 						{
 							TQ_treat = 1;
 							PQ_treat = 0;
+							G6PD_test = 0;
+
 
 							/////////////////////////////////////////////////////////////////////
 							// Exclude TQ because of pregancy
@@ -2118,10 +2411,18 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 								TQ_treat = 0;
 							}
 
+							//////////////////////////////////////////////////////////////////////////////////////////
+							// Is G6PD testing administered ? If so, count test
+
+							if ((TQ_treat == 1) && (theta.STAT_TQ_G6PD_test == 1))
+							{
+								G6PD_test = 1;
+							}
+
 							/////////////////////////////////////////////////////////////////////
-							// Exclude TQ because of G6PD deficiency
+							// Exclude TQ because of G6PD deficiency if there is testing
 
-							if ((theta.STAT_TQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 7.0))
+							if ((theta.STAT_TQ_G6PD_test == 1) && (theta.STAT_TQ_G6PD_risk == 1) && (POP.people[n].G6PD_activity < 7.0))
 							{
 								TQ_treat = 0;
 
@@ -2143,6 +2444,17 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 									TQ_effective = 1;
 								}
 
+								/////////////////////////////////////////////////////////////////////
+								// Is TQ adhered to?
+
+								if (genunf(0.0, 1.0) > theta.STAT_TQ_adhere)
+								{
+									PQ_effective = 0;
+								}
+
+								/////////////////////////////////////////////////////////////////////
+								// Is TQ metabolised?
+
 								if ((theta.STAT_TQ_CYP2D6_risk == 1) && (POP.people[n].CYP2D6 == 1))
 								{
 									TQ_effective = 0;
@@ -2156,6 +2468,17 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 									PQ_effective = 1;
 								}
 
+								/////////////////////////////////////////////////////////////////////
+								// Is PQ adhered to?
+
+								if (genunf(0.0, 1.0) > theta.STAT_PQ_adhere)
+								{
+									PQ_effective = 0;
+								}
+
+								/////////////////////////////////////////////////////////////////////
+								// Is PQ metabolised?
+
 								if ((theta.STAT_PQ_CYP2D6_risk == 1) && (POP.people[n].CYP2D6 == 1))
 								{
 									PQ_effective = 0;
@@ -2214,6 +2537,14 @@ void Intervention::distribute(double t, Params& theta, Population& POP)
 								POP.people[n].PQ_treat = 0;
 							}
 
+							if (G6PD_test == 1)
+							{
+								POP.people[n].G6PD_test = 1;
+							}
+							else {
+								POP.people[n].G6PD_test = 0;
+							}
+							
 							if ((PQ_treat == 1) && (PQ_effective == 1))
 							{
 								POP.people[n].Hyp = 0;
diff --git a/Pv_mod/Intervention.h b/Pv_mod/Intervention.h
index f43b3ccefc2b4bac8b78791d1794692bbbe843bf..740817e89cc306fa7674f873970913768107aef3 100644
--- a/Pv_mod/Intervention.h
+++ b/Pv_mod/Intervention.h
@@ -87,6 +87,7 @@ private:
 	vector<double> PQ_avail;       // availability of primaquine
 	vector<double> PQ_adhere;      // adherence to full primaquine regimen
 	vector<double> PQ_low_age;     // youngest age for primaquine treatment regimen
+	vector<int>	PQ_G6PD_test;      // G6PD testing for PQ eligible cases  (0 = no test; 1 = test)
 	vector<int>	PQ_G6PD_risk;      // Risk in G6PD-deficient individuals (0 = no risk; 1 = risk)
 	vector<int>	PQ_CYP2D6_risk;    // Risk of not working in low CYP2D6 metabolizers  (0 = no risk; 1 = risk, i.e. doesn't work)
 	vector<int>	PQ_preg_risk;      // Risk in pregnant women  (0 = no risk; 1 = risk)
@@ -105,11 +106,14 @@ private:
 	vector<double> TQ_avail;       // availability of primaquine
 	vector<double> TQ_adhere;      // adherence to full primaquine regimen
 	vector<double> TQ_low_age;     // youngest age for primaquine treatment regimen
+	vector<int>	TQ_G6PD_test;      // G6PD testing for TQ eligible cases  (0 = no test; 1 = test)
+	vector<int>	TQ_PQ_G6PD_test;   // G6PD testing for PQ eligible cases in TQ intervention (0 = no test; 1 = test)
 	vector<int>	TQ_G6PD_risk;      // Risk in G6PD-deficient individuals (0 = no risk; 1 = risk)
 	vector<int>	TQ_CYP2D6_risk;    // Risk of not working in low CYP2D6 metabolizers  (0 = no risk; 1 = risk, i.e. doesn't work)
 	vector<int>	TQ_preg_risk;      // Risk in pregnant women  (0 = no risk; 1 = risk)
 
 
+
 	////////////////////////////////
 	// Intervention 3 
 	// LLINs
@@ -148,6 +152,7 @@ private:
 	vector<double> MDA_PQ_PQproph;          // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	vector<double> MDA_PQ_adhere;           // Primaquine adherence
 	vector<double> MDA_PQ_low_age;          // Lower age limit for treatment (in days)
+	vector<int>	MDA_PQ_G6PD_test;			// G6PD testing for PQ eligible cases  (0 = no test; 1 = test)
 	vector<int> MDA_PQ_G6PD_risk;           // Risk in G6PD - deficient individuals
 	vector<int> MDA_PQ_CYP2D6_risk;         // Risk of not working in low CYP2D6 metabolizers
 	vector<int> MDA_PQ_preg_risk;           // Risk in pregnant women
@@ -165,6 +170,8 @@ private:
 	vector<double> MDA_TQ_TQproph;          // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	vector<double> MDA_TQ_adhere;           // Tafenoquine adherence
 	vector<double> MDA_TQ_low_age;          // Lower age limit for treatment (in days)
+	vector<int>	MDA_TQ_G6PD_test;			// G6PD testing for TQ eligible cases  (0 = no test; 1 = test)
+	vector<int>	MDA_TQ_PQ_G6PD_test;		// G6PD testing for PQ eligible cases in TQ intervention (0 = no test; 1 = test)
 	vector<int> MDA_TQ_G6PD_risk;           // Risk in G6PD - deficient individuals
 	vector<int> MDA_TQ_CYP2D6_risk;         // Risk of not working in low CYP2D6 metabolizers
 	vector<int> MDA_TQ_preg_risk;           // Risk in pregnant women
@@ -196,6 +203,7 @@ private:
 	vector<double> MSAT_PQ_PQproph;         // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	vector<double> MSAT_PQ_adhere;          // Primaquine adherence
 	vector<double> MSAT_PQ_low_age;         // Lower age limit for treatment (in days)
+	vector<int>	MSAT_PQ_G6PD_test;			// G6PD testing for PQ eligible cases  (0 = no test; 1 = test)
 	vector<int> MSAT_PQ_G6PD_risk;          // Risk in G6PD - deficient individuals
 	vector<int> MSAT_PQ_CYP2D6_risk;        // Risk of not working in low CYP2D6 metabolizers
 	vector<int> MSAT_PQ_preg_risk;          // Risk in pregnant women
@@ -215,6 +223,8 @@ private:
 	vector<double> MSAT_TQ_TQproph;         // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	vector<double> MSAT_TQ_adhere;          // Tafenoquine adherence 
 	vector<double> MSAT_TQ_low_age;         // Lower age limit for treatment (in days)
+	vector<int>	MSAT_TQ_G6PD_test;			// G6PD testing for TQ eligible cases  (0 = no test; 1 = test)
+	vector<int>	MSAT_TQ_PQ_G6PD_test;		// G6PD testing for PQ eligible cases in TQ intervention (0 = no test; 1 = test)
 	vector<int> MSAT_TQ_G6PD_risk;          // Risk in G6PD - deficient individuals
 	vector<int> MSAT_TQ_CYP2D6_risk;        // Risk of not working in low CYP2D6 metabolizers
 	vector<int> MSAT_TQ_preg_risk;          // Risk in pregnant women
@@ -234,6 +244,7 @@ private:
 	vector<double> STAT_PQ_PQproph;         // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	vector<double> STAT_PQ_adhere;          // Primaquine adherence
 	vector<double> STAT_PQ_low_age;         // Lower age limit for treatment (in days)
+	vector<int>	STAT_PQ_G6PD_test;			// G6PD testing for PQ eligible cases  (0 = no test; 1 = test)
 	vector<int> STAT_PQ_G6PD_risk;          // Risk in G6PD - deficient individuals
 	vector<int> STAT_PQ_CYP2D6_risk;        // Risk of not working in low CYP2D6 metabolizers
 	vector<int> STAT_PQ_preg_risk;          // Risk in pregnant women
@@ -253,6 +264,8 @@ private:
 	vector<double> STAT_TQ_TQproph;         // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	vector<double> STAT_TQ_adhere;          // Tafenoquine adherence
 	vector<double> STAT_TQ_low_age;         // Lower age limit for treatment (in days)
+	vector<int>	STAT_TQ_G6PD_test;			// G6PD testing for TQ eligible cases  (0 = no test; 1 = test)
+	vector<int>	STAT_TQ_PQ_G6PD_test;		// G6PD testing for PQ eligible cases in TQ intervention (0 = no test; 1 = test)
 	vector<int> STAT_TQ_G6PD_risk;          // Risk in G6PD - deficient individuals
 	vector<int> STAT_TQ_CYP2D6_risk;        // Risk of not working in low CYP2D6 metabolizers
 	vector<int> STAT_TQ_preg_risk;          // Risk in pregnant women
diff --git a/Pv_mod/Params.cpp b/Pv_mod/Params.cpp
index 72779977dede5b53afb00c94c19caf075d1828bd..db5cf62f598df563bd3432b55a936d192df2f4ce 100644
--- a/Pv_mod/Params.cpp
+++ b/Pv_mod/Params.cpp
@@ -177,6 +177,11 @@ SimTimes Params::read(const char *parameter_File, const char *mosquito_File[N_sp
 
 	parameter_Stream >> discard >> treat_cover >> discard;       // proportion of symptomatic cases treated
 	parameter_Stream >> discard >> treat_regimen >> discard;     // treatment regimen
+	
+	parameter_Stream >> discard >> PQ_G6PD_test >> discard;     // G6PD testing for PQ treatment
+	parameter_Stream >> discard >> TQ_G6PD_test >> discard;     // G6PD testing for TQ treatment
+	parameter_Stream >> discard >> TQ_PQ_G6PD_test >> discard;   // G6PD testing for PQ treatment in TQ intervention
+
 	parameter_Stream >> discard >> BS_eff >> discard;            // blood-stage treatment efficacy
 	parameter_Stream >> discard >> BS_proph >> discard;          // blood-stage treatment prophylaxis
 
@@ -211,8 +216,9 @@ SimTimes Params::read(const char *parameter_File, const char *mosquito_File[N_sp
 	PQ_PQeff = 1.0;               // primaquine efficacy
 	PQ_PQproph = 8.0;             // duration of primaquine prophylaxis (number of days + 1)
 	PQ_avail = 1.0;               // availability of primaquine
-	PQ_adhere = 0.62;             // adherence to full primaquine regimen
+	PQ_adhere = 0.622;            // adherence to full primaquine regimen
 	PQ_low_age = 180.0;           // youngest age for primaquine treatment regimen
+	PQ_G6PD_test = 0;			  // G6PD testing for PQ eligible cases  (0 = no test; 1 = test)
 	PQ_G6PD_risk = 1;             // Risk in G6PD-deficient individuals (0 = no risk; 1 = risk)
 	PQ_CYP2D6_risk = 1;           // Risk of not working in low CYP2D6 metabolizers  (0 = no risk; 1 = risk, i.e. doesn't work)
 	PQ_preg_risk = 1;             // Risk in pregnant women  (0 = no risk; 1 = risk)
@@ -224,6 +230,8 @@ SimTimes Params::read(const char *parameter_File, const char *mosquito_File[N_sp
 	TQ_avail = 1.0;               // availability of tafenoquine
 	TQ_adhere = 1.0;              // adherence to full tafenoquine regimen
 	TQ_low_age = 16.0*365.0;      // youngest age for tafenoquine treatment regimen
+	TQ_G6PD_test = 1;			  // G6PD testing for TQ eligible cases  (0 = no test; 1 = test)
+	TQ_PQ_G6PD_test = 0;		  // G6PD testing for PQ eligible cases in TQ intervention (0 = no test; 1 = test)
 	TQ_G6PD_risk = 1;             // Risk in G6PD-deficient individuals (0 = no risk; 1 = risk)
 	TQ_CYP2D6_risk = 0;           // Risk of not working in low CYP2D6 metabolizers  (0 = no risk; 1 = risk, i.e. doesn't work)
 	TQ_preg_risk = 1;             // Risk in pregnant women  (0 = no risk; 1 = risk)
@@ -239,6 +247,7 @@ SimTimes Params::read(const char *parameter_File, const char *mosquito_File[N_sp
 	MDA_PQ_PQproph = 8.0;         // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	MDA_PQ_adhere = 0.62;         // Primaquine adherence
 	MDA_PQ_low_age = 180.0;       // Lower age limit for treatment (in days)
+	MDA_PQ_G6PD_test = 0;		  // G6PD testing for PQ eligible cases  (0 = no test; 1 = test)
 	MDA_PQ_G6PD_risk = 1;         // Risk in G6PD - deficient individuals
 	MDA_PQ_CYP2D6_risk = 1;       // Risk of not working in low CYP2D6 metabolizers
 	MDA_PQ_preg_risk = 1;         // Risk in pregnant women
@@ -250,6 +259,8 @@ SimTimes Params::read(const char *parameter_File, const char *mosquito_File[N_sp
 	MDA_TQ_TQproph = 45.0;        // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	MDA_TQ_adhere = 1.0;          // Tafenoquine adherence
 	MDA_TQ_low_age = 16.0*365.0;  // Lower age limit for treatment (in days)
+	MDA_TQ_G6PD_test = 1;		  // G6PD testing for TQ eligible cases  (0 = no test; 1 = test)
+	MDA_TQ_PQ_G6PD_test = 0;	  // G6PD testing for PQ eligible cases in TQ intervention (0 = no test; 1 = test)
 	MDA_TQ_G6PD_risk = 1;         // Risk in G6PD - deficient individuals
 	MDA_TQ_CYP2D6_risk = 0;       // Risk of not working in low CYP2D6 metabolizers
 	MDA_TQ_preg_risk = 1;         // Risk in pregnant women
@@ -269,6 +280,7 @@ SimTimes Params::read(const char *parameter_File, const char *mosquito_File[N_sp
 	MSAT_PQ_PQproph = 8.0;        // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	MSAT_PQ_adhere = 0.62;        // Primaquine adherence
 	MSAT_PQ_low_age = 180.0;      // Lower age limit for treatment (in days)
+	MSAT_PQ_G6PD_test = 0;		  // G6PD testing for PQ eligible cases  (0 = no test; 1 = test)
 	MSAT_PQ_G6PD_risk = 1;        // Risk in G6PD - deficient individuals
 	MSAT_PQ_CYP2D6_risk = 1;      // Risk of not working in low CYP2D6 metabolizers
 	MSAT_PQ_preg_risk = 1;        // Risk in pregnant women
@@ -282,6 +294,8 @@ SimTimes Params::read(const char *parameter_File, const char *mosquito_File[N_sp
 	MSAT_TQ_TQproph = 45.0;       // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	MSAT_TQ_adhere = 1.0;         // Tafenoquine adherence
 	MSAT_TQ_low_age = 16.0*365.0; // Lower age limit for treatment (in days)
+	MSAT_TQ_G6PD_test = 0;		  // G6PD testing for TQ eligible cases  (0 = no test; 1 = test)
+	MSAT_TQ_PQ_G6PD_test = 0;	  // G6PD testing for PQ eligible cases in TQ intervention (0 = no test; 1 = test)
 	MSAT_TQ_G6PD_risk = 1;        // Risk in G6PD - deficient individuals
 	MSAT_TQ_CYP2D6_risk = 0;      // Risk of not working in low CYP2D6 metabolizers
 	MSAT_TQ_preg_risk = 1;        // Risk in pregnant women
@@ -295,6 +309,7 @@ SimTimes Params::read(const char *parameter_File, const char *mosquito_File[N_sp
 	STAT_PQ_PQproph = 8.0;        // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	STAT_PQ_adhere = 0.62;        // Primaquien adherence
 	STAT_PQ_low_age = 180.0;      // Lower age limit for treatment (in days)
+	STAT_PQ_G6PD_test = 0;		  // G6PD testing for PQ eligible cases  (0 = no test; 1 = test)
 	STAT_PQ_G6PD_risk = 1;        // Risk in G6PD - deficient individuals
 	STAT_PQ_CYP2D6_risk = 1;      // Risk of not working in low CYP2D6 metabolizers
 	STAT_PQ_preg_risk = 1;        // Risk in pregnant women
@@ -308,6 +323,8 @@ SimTimes Params::read(const char *parameter_File, const char *mosquito_File[N_sp
 	STAT_TQ_TQproph = 45.0;       // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	STAT_TQ_adhere = 1.0;         // Lower age limit for treatment(in years)
 	STAT_TQ_low_age = 16.0*365.0; // Lower age limit for treatment(in years)
+	STAT_TQ_G6PD_test = 0;		  // G6PD testing for TQ eligible cases  (0 = no test; 1 = test)
+	STAT_TQ_PQ_G6PD_test = 0;	  // G6PD testing for PQ eligible cases in TQ intervention (0 = no test; 1 = test)
 	STAT_TQ_G6PD_risk = 1;        // Risk in G6PD - deficient individuals
 	STAT_TQ_CYP2D6_risk = 0;      // Risk of not working in low CYP2D6 metabolizers
 	STAT_TQ_preg_risk = 1;        // Risk in pregnant women
diff --git a/Pv_mod/Params.h b/Pv_mod/Params.h
index a52ea91315caa6b422cf4f23fc43c53f5c60b9d4..31ffce76d6d44ec4496d90f9795ac5863a407d43 100644
--- a/Pv_mod/Params.h
+++ b/Pv_mod/Params.h
@@ -209,7 +209,7 @@ struct Params
 
 
 	///////////////////////////////
-	// Larval paramters
+	// Larval parameters
 
 	double d_E_larvae;              // Development time of early larval instars
 	double d_L_larvae;              // Development time of late larval instars
@@ -268,6 +268,7 @@ struct Params
 	double PQ_avail;               // availability of primaquine
 	double PQ_adhere;              // adherence to full primaquine regimen
 	double PQ_low_age;             // youngest age for primaquine treatment regimen
+	int PQ_G6PD_test;			   // G6PD testing for PQ eligible cases  (0 = no test; 1 = test)
 	int	PQ_G6PD_risk;              // Risk in G6PD-deficient individuals (0 = no risk; 1 = risk)
 	int	PQ_CYP2D6_risk;            // Risk of not working in low CYP2D6 metabolizers  (0 = no risk; 1 = risk, i.e. doesn't work)
 	int	PQ_preg_risk;              // Risk in pregnant women  (0 = no risk; 1 = risk)
@@ -284,6 +285,8 @@ struct Params
 	double TQ_avail;               // availability of tafenoquine
 	double TQ_adhere;              // adherence to full tafenoquine regimen
 	double TQ_low_age;             // youngest age for tafenoquine treatment regimen
+	int TQ_G6PD_test;			   // G6PD testing for TQ eligible cases  (0 = no test; 1 = test)
+	int TQ_PQ_G6PD_test;		   // G6PD testing for PQ eligible cases in TQ intervention (0 = no test; 1 = test)
 	int	TQ_G6PD_risk;              // Risk in G6PD-deficient individuals (0 = no risk; 1 = risk)
 	int	TQ_CYP2D6_risk;            // Risk of not working in low CYP2D6 metabolizers  (0 = no risk; 1 = risk, i.e. doesn't work)
 	int	TQ_preg_risk;              // Risk in pregnant women  (0 = no risk; 1 = risk)
@@ -309,6 +312,7 @@ struct Params
 	double MDA_PQ_PQproph;          // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	double MDA_PQ_adhere;           // Primaquine adherence
 	double MDA_PQ_low_age;          // Lower age limit for treatment (in days)
+	int MDA_PQ_G6PD_test;			// G6PD testing for PQ eligible cases  (0 = no test; 1 = test)
 	int MDA_PQ_G6PD_risk;           // Risk in G6PD - deficient individuals
 	int MDA_PQ_CYP2D6_risk;         // Risk of not working in low CYP2D6 metabolizers
 	int MDA_PQ_preg_risk;           // Risk in pregnant women
@@ -325,6 +329,8 @@ struct Params
 	double MDA_TQ_TQproph;          // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	double MDA_TQ_adhere;           // Tafenoquine adherence
 	double MDA_TQ_low_age;          // Lower age limit for treatment (in days)
+	int MDA_TQ_G6PD_test;			// G6PD testing for TQ eligible cases  (0 = no test; 1 = test)
+	int MDA_TQ_PQ_G6PD_test;		// G6PD testing for PQ eligible cases in TQ intervention  (0 = no test; 1 = test)
 	int MDA_TQ_G6PD_risk;           // Risk in G6PD - deficient individuals
 	int MDA_TQ_CYP2D6_risk;         // Risk of not working in low CYP2D6 metabolizers
 	int MDA_TQ_preg_risk;           // Risk in pregnant women
@@ -354,6 +360,7 @@ struct Params
 	double MSAT_PQ_PQproph;         // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	double MSAT_PQ_adhere;          // Primaquine adherence
 	double MSAT_PQ_low_age;         // Lower age limit for treatment (in days)
+	int MSAT_PQ_G6PD_test;			// G6PD testing for PQ eligible cases  (0 = no test; 1 = test)
 	int MSAT_PQ_G6PD_risk;          // Risk in G6PD - deficient individuals
 	int MSAT_PQ_CYP2D6_risk;        // Risk of not working in low CYP2D6 metabolizers
 	int MSAT_PQ_preg_risk;          // Risk in pregnant women
@@ -372,6 +379,8 @@ struct Params
 	double MSAT_TQ_TQproph;         // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	double MSAT_TQ_adhere;          // Tafenqouine adherence
 	double MSAT_TQ_low_age;         // Lower age limit for treatment (in days)
+	int MSAT_TQ_G6PD_test;			// G6PD testing for TQ eligible cases  (0 = no test; 1 = test)
+	int MSAT_TQ_PQ_G6PD_test;		// G6PD testing for PQ eligible cases in TQ intervention  (0 = no test; 1 = test)
 	int MSAT_TQ_G6PD_risk;          // Risk in G6PD - deficient individuals
 	int MSAT_TQ_CYP2D6_risk;        // Risk of not working in low CYP2D6 metabolizers
 	int MSAT_TQ_preg_risk;          // Risk in pregnant women
@@ -390,6 +399,7 @@ struct Params
 	double STAT_PQ_PQproph;         // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	double STAT_PQ_adhere;          // Primaquine adherence
 	double STAT_PQ_low_age;         // Lower age limit for treatment (in days)
+	int STAT_PQ_G6PD_test;			// G6PD testing for PQ eligible cases  (0 = no test; 1 = test)
 	int STAT_PQ_G6PD_risk;          // Risk in G6PD - deficient individuals
 	int STAT_PQ_CYP2D6_risk;        // Risk of not working in low CYP2D6 metabolizers
 	int STAT_PQ_preg_risk;          // Risk in pregnant women
@@ -408,6 +418,8 @@ struct Params
 	double STAT_TQ_TQproph;         // Duration of primaquine prophylaxis(prevents new hypnozoites)
 	double STAT_TQ_adhere;          // Tafenoquine adherence
 	double STAT_TQ_low_age;         // Lower age limit for treatment (in days)
+	int STAT_TQ_G6PD_test;			// G6PD testing for PQ eligible cases  (0 = no test; 1 = test)
+	int STAT_TQ_PQ_G6PD_test;		// G6PD testing for PQ eligible cases in TQ intervention  (0 = no test; 1 = test)
 	int STAT_TQ_G6PD_risk;          // Risk in G6PD - deficient individuals
 	int STAT_TQ_CYP2D6_risk;        // Risk of not working in low CYP2D6 metabolizers
 	int STAT_TQ_preg_risk;          // Risk in pregnant women
diff --git a/Pv_mod/Population.cpp b/Pv_mod/Population.cpp
index c4b566b76b50cafb8865c71f6caf293bac3daa18..d2e4234145185823d00e71ec882617bdef859081 100644
--- a/Pv_mod/Population.cpp
+++ b/Pv_mod/Population.cpp
@@ -452,7 +452,7 @@ void Population::summary()
 		yH[k] = 0.0;
 	}
 
-	for (int k = 0; k < 12; k++)
+	for (int k = 0; k < 15; k++)
 	{
 		prev_all[k] = 0.0;
 		prev_U5[k] = 0.0;
@@ -504,6 +504,9 @@ void Population::summary()
 		prev_all[10] = prev_all[10] + people[n].PQ_treat;
 		prev_all[11] = prev_all[11] + people[n].TQ_treat;
 
+		prev_all[12] = prev_all[12] + people[n].G6PD_test;
+		prev_all[13] = prev_all[13] + people[n].PQ_effective;
+		prev_all[14] = prev_all[14] + people[n].TQ_effective;
 
 		//////////////////////////////////////////////
 		//////////////////////////////////////////////
@@ -537,6 +540,10 @@ void Population::summary()
 			prev_U5[9]  = prev_U5[9]  + people[n].BS_treat;
 			prev_U5[10] = prev_U5[10] + people[n].PQ_treat;
 			prev_U5[11] = prev_U5[11] + people[n].TQ_treat;
+
+			prev_U5[12] = prev_U5[12] + people[n].G6PD_test;
+			prev_U5[13] = prev_U5[13] + people[n].PQ_effective;
+			prev_U5[14] = prev_U5[14] + people[n].TQ_effective;
 		}
 
 		//////////////////////////////////////////////
@@ -571,6 +578,10 @@ void Population::summary()
 			prev_U10[9]  = prev_U10[9]  + people[n].BS_treat;
 			prev_U10[10] = prev_U10[10] + people[n].PQ_treat;
 			prev_U10[11] = prev_U10[11] + people[n].TQ_treat;
+
+			prev_U10[12] = prev_U10[12] + people[n].G6PD_test;
+			prev_U10[13] = prev_U10[13] + people[n].PQ_effective;
+			prev_U10[14] = prev_U10[14] + people[n].TQ_effective;
 		}
 	}
 
diff --git a/Pv_mod/Population.h b/Pv_mod/Population.h
index fdcd50ac83967e99dd7583231ec7b90426aef174..a0e8933d5a352943036bbfc198f766c4f8a5a796 100644
--- a/Pv_mod/Population.h
+++ b/Pv_mod/Population.h
@@ -101,9 +101,9 @@ public:
 
 	int yH[N_H_comp];   // Human compartmental states
 
-	int prev_all[12];   // Contains {N_pop, PvPR_PCR, PvPR_LM, Pv_clin, PvHR, PvHR_batches, new_PCR, new_LM, new_D, new_ACT, new_PQ, new_TQ} 
-	int prev_U5[12];    // Contains {N_pop, PvPR_PCR, PvPR_LM, Pv_clin, PvHR, PvHR_batches, new_PCR, new_LM, new_D, new_ACT, new_PQ, new_TQ} 
-	int prev_U10[12];   // Contains {N_pop, PvPR_PCR, PvPR_LM, Pv_clin, PvHR, PvHR_batches, new_PCR, new_LM, new_D, new_ACT, new_PQ, new_TQ} 
+	int prev_all[15];   // Contains {N_pop, PvPR_PCR, PvPR_LM, Pv_clin, PvHR, PvHR_batches, new_PCR, new_LM, new_D, new_ACT, new_PQ, new_TQ, G6PD_test, PQ_effective, TQ_effective} 
+	int prev_U5[15];    // Contains {N_pop, PvPR_PCR, PvPR_LM, Pv_clin, PvHR, PvHR_batches, new_PCR, new_LM, new_D, new_ACT, new_PQ, new_TQ, G6PD_test, PQ_effective, TQ_effective} 
+	int prev_U10[15];   // Contains {N_pop, PvPR_PCR, PvPR_LM, Pv_clin, PvHR, PvHR_batches, new_PCR, new_LM, new_D, new_ACT, new_PQ, new_TQ, G6PD_test, PQ_effective, TQ_effective} 
 
 	double EIR_t;            // EIR
 	int LLIN_cov_t;          // LLIN coverage
diff --git a/Pv_mod/Simulation.cpp b/Pv_mod/Simulation.cpp
index fac6deea2834507eb1d44567e93c9b48193a0f50..385ca9b0763e4869d403a207325108941f668a50 100644
--- a/Pv_mod/Simulation.cpp
+++ b/Pv_mod/Simulation.cpp
@@ -66,19 +66,19 @@ Simulation::Simulation(SimTimes times) :
 	prev_all.resize(N_time);
 	for (int i = 0; i < N_time; i++)
 	{
-		prev_all[i].resize(12);
+		prev_all[i].resize(15);
 	}
 
 	prev_U5.resize(N_time);
 	for (int i = 0; i < N_time; i++)
 	{
-		prev_U5[i].resize(12);
+		prev_U5[i].resize(15);
 	}
 
 	prev_U10.resize(N_time);
 	for (int i = 0; i < N_time; i++)
 	{
-		prev_U10[i].resize(12);
+		prev_U10[i].resize(15);
 	}
 
 	EIR_t.resize(N_time);
@@ -142,7 +142,7 @@ void Simulation::run(Params& theta, Population& POP, Intervention& INTVEN)
 			}
 		}
 
-		for (int k = 0; k < 12; k++)
+		for (int k = 0; k < 15; k++)
 		{
 			prev_all[i][k] = POP.prev_all[k];
 			prev_U5[i][k] = POP.prev_U5[k];
@@ -209,17 +209,17 @@ void Simulation::write_output(const char *output_File)
 			}
 		}
 
-		for (int k = 0; k < 12; k++)
+		for (int k = 0; k < 15; k++)
 		{
 			output_Stream << prev_all[i][k] << "\t";
 		}
 
 		// Write output for age categories U5 and U10
-		/*for (int k = 0; k<12; k++)
+		/*for (int k = 0; k<15; k++)
 		{
 			output_Stream << prev_U5[i][k] << "\t";
 		}
-		for (int k = 0; k<12; k++)
+		for (int k = 0; k<15; k++)
 		{
 			output_Stream << prev_U10[i][k] << "\t";
 		}*/