improve randomization (or not randomization) for non-combined factors

Source/StudyFrameworkPlugin/Private/SFStudyFactor.cpp

@@ -39,6 +39,18 @@ TSharedPtr<FJsonObject> USFStudyFactor::GetAsJson() const
 		FSFLoggingUtils::Log("[USFStudyFactor::GetAsJson] unknown MixingOrder!", true);
 	}
 
+	switch (NonCombinedMixingOrder)
+	{
+	case ENonCombinedFactorMixingOrder::RandomOrder:
+		Json->SetStringField("NonCombinedMixingOrder", "RandomOrder");
+		break;
+	case ENonCombinedFactorMixingOrder::InOrder:
+		Json->SetStringField("NonCombinedMixingOrder", "InOrder");
+		break;
+	default:
+		FSFLoggingUtils::Log("[USFStudyFactor::GetAsJson] unknown NonCombinedMixingOrder!", true);
+	}
+
 	switch (Type)
 	{
 	case EFactorType::Within:
@@ -85,6 +97,20 @@ void USFStudyFactor::FromJson(TSharedPtr<FJsonObject> Json)
 		FSFLoggingUtils::Log("[USFStudyFactor::FromJson] unknown MixingOrder: " + MixingOrderStr, true);
 	}
 
+	FString NonCombinedMixingOrderStr = Json->GetStringField("NonCombinedMixingOrder");
+	if (NonCombinedMixingOrderStr == "RandomOrder")
+	{
+		NonCombinedMixingOrder = ENonCombinedFactorMixingOrder::RandomOrder;
+	}
+	else if (NonCombinedMixingOrderStr == "InOrder")
+	{
+		NonCombinedMixingOrder = ENonCombinedFactorMixingOrder::InOrder;
+	}
+	else
+	{
+		FSFLoggingUtils::Log("[USFStudyFactor::FromJson] unknown NonCombinedMixingOrder: " + MixingOrderStr, true);
+	}
+
 	FString TypeStr = Json->GetStringField("Type");
 	if (TypeStr == "Within")
 	{
@@ -109,10 +135,6 @@ bool USFStudyFactor::CanEditChange(const FProperty * InProperty) const
 	{
 		return false;
 	}
-	if(InProperty->GetFName()=="Type" && bNonCombined)
-	{
-		return false;
-	}
 	return true;
 }
 
@@ -164,3 +186,25 @@ TArray<int> USFStudyFactor::GenerateLatinSquareOrder(int OrderNr, int NrConditio
 
 	return Result;
 }
+
+TArray<int> USFStudyFactor::GenerateRandomOrder(int OrderNr, int NrConditions)
+{
+	//not the most efficient implementation, but straight forward. Efficiency is not so important when creating study runs.
+	FRandomStream RNG(OrderNr);
+	//Create Ordered List;
+	TArray<int> Conditions;
+	for (int i = 0; i < NrConditions; ++i)
+	{
+		Conditions.Add(i);
+	}
+
+	TArray<int> RandomConditions;
+	for (int i = 0; i < NrConditions; ++i)
+	{
+		int RandomIndex = RNG.RandRange(0, Conditions.Num() - 1);
+		RandomConditions.Add(Conditions[RandomIndex]);
+		Conditions.RemoveAt(RandomIndex);
+	}
+	check(Conditions.Num()==0)
+	return RandomConditions;
+}

Source/StudyFrameworkPlugin/Private/SFStudyPhase.cpp

@@ -204,8 +204,9 @@ TArray<USFCondition*> USFStudyPhase::GenerateConditions(int ParticipantSequenceN
 			continue;
 		}
 
-		TArray<int> LatinSquare = USFStudyFactor::GenerateLatinSquareOrder(ParticipantSequenceNr + PhaseIndex, Factor->Levels.Num());
-		if (LatinSquare.Num() < ConditionsIndices.Num())
+		TArray<int> RandomOrder = {};
+		int RandomOrderIndex = 0;
+		if (Factor->Levels.Num() < ConditionsIndices.Num())
 		{
 			FSFLoggingUtils::Log(
 				"[USFStudyPhase::GenerateConditions] nonCombined factor levels will be repeated, since factor " + Factor->
@@ -216,8 +217,27 @@ TArray<USFCondition*> USFStudyPhase::GenerateConditions(int ParticipantSequenceN
 		{
 			check(ConditionsIndices[j][i]==-1);
 
-			//repeat the latin square if it does not provide enough levels
-			ConditionsIndices[j][i] = LatinSquare[j % Factor->Levels.Num()];
+			if(RandomOrderIndex >= RandomOrder.Num())
+			{
+				//generate a new random order (since we maybe have to repeat the levels of this factor and then each repetition should be random
+				RandomOrder = USFStudyFactor::GenerateRandomOrder(ParticipantSequenceNr + PhaseIndex + i + j, Factor->Levels.Num());
+				RandomOrderIndex = 0;
+			}
+
+			if(Factor->NonCombinedMixingOrder == ENonCombinedFactorMixingOrder::RandomOrder)
+			{
+				ConditionsIndices[j][i] = RandomOrder[RandomOrderIndex++];
+			}
+			else if (Factor->NonCombinedMixingOrder == ENonCombinedFactorMixingOrder::InOrder)
+			{
+				ConditionsIndices[j][i] = RandomOrderIndex++;
+			}
+			else
+			{
+				FSFLoggingUtils::Log(
+					"[USFStudyPhase::GenerateConditions] unknown non-combined mixing order!");
+			}
+			
 		}
 	}
 

Source/StudyFrameworkPlugin/Public/SFStudyFactor.h

@@ -14,6 +14,13 @@ enum class EFactorMixingOrder : uint8
 	InOrder = 2 UMETA(DisplayName = "In Order: The levels of this factor well be kept in specified order")
 };
 
+UENUM()
+enum class ENonCombinedFactorMixingOrder : uint8
+{
+	RandomOrder = 0 UMETA(DisplayName = "Random: Fully random using random sequences, seeded by participant running number"),
+	InOrder = 1 UMETA(DisplayName = "In Order: So Latin-Square randomization of the other factors should lead to equal mapping of conditions to non-combined factor levels")
+};
+
 UENUM()
 enum class EFactorType : uint8
 {
@@ -47,24 +54,25 @@ public:
 	UPROPERTY(BlueprintReadOnly, EditAnywhere)
 	TArray<FString> Levels;
 
-	//how to mix this Factor
-	UPROPERTY(BlueprintReadOnly, EditAnywhere)
-	EFactorMixingOrder MixingOrder = EFactorMixingOrder::RandomOrder;
-
-	//Whether it is a within or between subjects factor
-	UPROPERTY(BlueprintReadOnly, EditAnywhere)
-	EFactorType Type = EFactorType::Within;
-
 	/*
 	*	bNonCombined means this factor is just used to introduce randomness
 	*	In contrast to normal factors it is not combined with the other factors in
 	*	a n x m x ... design but run in parallel, e.g., to introduce some randomness
 	*	to repetitions of the same conditions (of the other factors).
-	*	Currently these are then randomized between all subjects using LatinSquare
-	*	(and repeated in the same order if not enough levels).
 	*/
 	UPROPERTY(BlueprintReadOnly, EditAnywhere)
 	bool bNonCombined = false;
 
+	//how to mix this Factor
+	UPROPERTY(BlueprintReadOnly, EditAnywhere, meta = (EditCondition = "!bNonCombined", EditConditionHides))
+	EFactorMixingOrder MixingOrder = EFactorMixingOrder::RandomOrder;
+	UPROPERTY(BlueprintReadOnly, EditAnywhere, meta = (EditCondition = "bNonCombined", EditConditionHides))
+	ENonCombinedFactorMixingOrder NonCombinedMixingOrder = ENonCombinedFactorMixingOrder::RandomOrder;
+
+	//Whether it is a within or between subjects factor
+	UPROPERTY(BlueprintReadOnly, EditAnywhere, meta = (EditCondition = "!bNonCombined", EditConditionHides))
+	EFactorType Type = EFactorType::Within;
+
 	static TArray<int> GenerateLatinSquareOrder(int OrderNr, int NrConditions);
+	static TArray<int> GenerateRandomOrder(int OrderNr, int NrConditions);
 };