private static void GenerateQueryType(
CodeGenerationResult result,
DataGeneratorContext dataContext,
CodeGeneratorContext generatorContext,
IReadOnlyList <IObjectType> objectTypes)
{
ClassDeclarationSyntax queryDeclaration =
ClassDeclaration("Query") // todo : we need to read the name from the config
.AddModifiers(
Token(SyntaxKind.PublicKeyword),
Token(SyntaxKind.PartialKeyword))
.AddGeneratedAttribute()
.AddExtendObjectTypeAttribute("Query");
foreach (IObjectType?objectType in objectTypes)
{
queryDeclaration = queryDeclaration.AddMembers(
CreateQueryResolver(dataContext, generatorContext, objectType));
GenerateObjectType(result, generatorContext.Namespace !, objectType);
}
NamespaceDeclarationSyntax namespaceDeclaration =
NamespaceDeclaration(IdentifierName(generatorContext.Namespace !))
.AddMembers(queryDeclaration);
CompilationUnitSyntax compilationUnit =
CompilationUnit()
.AddMembers(namespaceDeclaration);
compilationUnit = compilationUnit.NormalizeWhitespace(elasticTrivia: true);
result.AddSource(generatorContext.Namespace !+".Query.cs", compilationUnit.ToFullString());
}
private static MethodDeclarationSyntax CreateQueryResolver(
DataGeneratorContext dataContext,
CodeGeneratorContext generatorContext,
IObjectType objectType)
{
const string session = nameof(session);
dataContext = DataGeneratorContext.FromMember(objectType, dataContext);
TypeNameDirective?typeNameDirective =
objectType.GetFirstDirective <TypeNameDirective>("typeName");
var typeName = typeNameDirective?.Name ?? objectType.Name.Value;
var pluralTypeName = typeNameDirective?.PluralName ?? typeName + "s";
MethodDeclarationSyntax resolverSyntax =
MethodDeclaration(
GenericName(Identifier(Global(Neo4JExecutable)))
.WithTypeArgumentList(
TypeArgumentList(
SingletonSeparatedList <TypeSyntax>(
IdentifierName(typeName)))),
Identifier("Get" + pluralTypeName))
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword)))
.WithParameterList(
ParameterList(
SingletonSeparatedList(
Parameter(Identifier(session))
.AddScopedServiceAttribute()
.WithType(IdentifierName(Global(IAsyncSession))))))
.WithExpressionBody(
ArrowExpressionClause(
ImplicitObjectCreationExpression()
.WithArgumentList(
ArgumentList(SingletonSeparatedList(
Argument(IdentifierName("session")))))))
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken))
.AddGraphQLNameAttribute(GraphQLFieldName(pluralTypeName))
.AddNeo4JDatabaseAttribute(generatorContext.DatabaseName)
.AddPagingAttribute(dataContext.Paging)
.AddProjectionAttribute();
if (dataContext.Filtering)
{
resolverSyntax = resolverSyntax.AddFilteringAttribute();
}
if (dataContext.Sorting)
{
resolverSyntax = resolverSyntax.AddSortingAttribute();
}
return(resolverSyntax);
}
public void CheckOrganizationDegreeFromResults()
{
var simNumber = 9;
var dbContext = MasterDBContext.GetContext(testCtxString);
var dbResultCtx = ResultContext.GetContext(testResultCtxString);
var dbGeneratorCtx = DataGeneratorContext.GetContext(testGeneratorCtxString);
var transitionMatrixGeneratorVerifier = new TransitionMatrixGeneratorVerifier();
transitionMatrixGeneratorVerifier.VerifySimulatedData(dbContext, dbGeneratorCtx, dbResultCtx, simNumber);
Assert.True(true);
}
public CodeGenerationResult Generate(CodeGeneratorContext context)
{
var result = new CodeGenerationResult();
ISchema schema = SchemaHelper.CreateSchema(context.Documents);
GenerateTypes(
result,
DataGeneratorContext.FromSchema(schema),
context,
schema);
return(result);
}
public static Approach GetApproachById(DataGeneratorContext ctx, int id)
{
var approach = ctx.Approaches
.Include(x => x.BomInput)
.Include(x => x.ProductStructureInput)
.Include(x => x.TransitionMatrixInput)
.ThenInclude(x => x.WorkingStations)
.ThenInclude(x => x.MachiningTimeParameterSet)
.Include(x => x.TransitionMatrixInput)
.ThenInclude(x => x.GeneralMachiningTimeParameterSet)
.Single(predicate: (x => x.Id == id));
return(approach);
}
private static void GenerateTypes(
CodeGenerationResult result,
DataGeneratorContext dataContext,
CodeGeneratorContext generatorContext,
ISchema schema)
{
GenerateQueryType(
result,
dataContext,
generatorContext,
schema.Types
.OfType <ObjectType>()
.Where(type => !IntrospectionTypes.IsIntrospectionType(type))
.ToList());
GenerateDependencyInjectionCode(
result,
generatorContext);
}
public void ResetResultsDB(string connectionString, string resultConnectionString, string generatorConnectionString)
{
MasterDBContext masterCtx = MasterDBContext.GetContext(connectionString);
masterCtx.Database.EnsureDeleted();
masterCtx.Database.EnsureCreated();
MasterDBInitializerTruck.DbInitialize(masterCtx, ModelSize.Medium, ModelSize.Small, ModelSize.Small, 3, false);
ResultContext results = ResultContext.GetContext(resultCon: resultConnectionString);
results.Database.EnsureDeleted();
results.Database.EnsureCreated();
ResultDBInitializerBasic.DbInitialize(results);
DataGeneratorContext generatorCtx = DataGeneratorContext.GetContext(generatorConnectionString);
generatorCtx.Database.EnsureDeleted();
generatorCtx.Database.EnsureCreated();
}
public void GenerateData() //Generierung für Simulation direkt im Testfall, wo Simulation durchgeführt wird
{
for (var i = 5; i < 6; i++)
{
var approachId = i;
var generatorDbCtx = DataGeneratorContext.GetContext(testGeneratorCtxString);
var approach = ApproachRepository.GetApproachById(generatorDbCtx, approachId);
/*var parameterSet = ParameterSet.Create(new object[] { Dbms.GetNewMasterDataBase(false, "Master40") });
* var dataBase = parameterSet.GetOption<DataBase<ProductionDomainContext>>();*/
var dbContext = MasterDBContext.GetContext(testCtxString);
var resultContext = ResultContext.GetContext(testResultCtxString);
var generator = new MainGenerator();
generator.StartGeneration(approach, dbContext, resultContext, true);
}
Assert.True(true);
}
public void VerifySimulatedData(MasterDBContext dbContext, DataGeneratorContext dbGeneratorCtx,
ResultContext dbResultCtx, int simNumber)
{
var simulation = SimulationRepository.GetSimulationById(simNumber, dbGeneratorCtx);
if (simulation != null)
{
var approach = ApproachRepository.GetApproachById(dbGeneratorCtx, simulation.ApproachId);
if (approach.TransitionMatrixInput.ExtendedTransitionMatrix)
{
var generator = new MainGenerator();
generator.StartGeneration(approach, dbContext, dbResultCtx);
var articleCount =
ArticleRepository.GetArticleNamesAndCountForEachUsedArticleInSimulation(dbResultCtx, simNumber);
var articlesByNames =
ArticleRepository.GetArticlesByNames(articleCount.Keys.ToHashSet(), dbContext);
var capabilities = ResourceCapabilityRepository.GetParentResourceCapabilities(dbContext);
var actualTransitionMatrix = new TransitionMatrix
{
Pi = new double[capabilities.Count + 1, capabilities.Count + 1]
};
var capPosByCapId = new Dictionary <int, int>();
foreach (var cap in capabilities)
{
var number = cap.Name.Substring(0, cap.Name.IndexOf(" "));
var pos = AlphabeticNumbering.GetNumericRepresentation(number);
capPosByCapId.Add(cap.Id, pos);
}
foreach (var a in articlesByNames)
{
var operations = a.Value.Operations.ToList();
operations.Sort((o1, o2) => o1.HierarchyNumber.CompareTo(o2.HierarchyNumber));
var operationCount = 0;
var lastCapPos = 0;
do
{
var capPos =
capPosByCapId[
operations[operationCount].ResourceCapability.ParentResourceCapability.Id];
actualTransitionMatrix.Pi[lastCapPos, capPos] += articleCount[a.Key];
lastCapPos = capPos + 1;
operationCount++;
} while (operationCount < operations.Count);
actualTransitionMatrix.Pi[lastCapPos, capabilities.Count] += articleCount[a.Key];
}
for (var i = 0; i <= capabilities.Count; i++)
{
var sum = 0.0;
for (var j = 0; j <= capabilities.Count; j++)
{
sum += actualTransitionMatrix.Pi[i, j];
}
for (var j = 0; j <= capabilities.Count; j++)
{
actualTransitionMatrix.Pi[i, j] /= sum;
}
}
var transitionMatrixGenerator = new TransitionMatrixGenerator();
ActualOrganizationDegree = transitionMatrixGenerator.CalcOrganizationDegree(
actualTransitionMatrix.Pi,
capabilities.Count + 1);
GeneratedOrganizationDegree = transitionMatrixGenerator.CalcOrganizationDegree(
generator.TransitionMatrix.Pi,
capabilities.Count + 1);
System.Diagnostics.Debug.WriteLine("################################# Executed work plans have an organization degree of " + ActualOrganizationDegree + " (transition matrix has " + GeneratedOrganizationDegree + "; input was " + approach.TransitionMatrixInput.DegreeOfOrganization + ")");
}
}
}
public static Simulation GetSimulationById(int id, DataGeneratorContext ctx)
{
return(ctx.Simulations.SingleOrDefault(x => x.Id == id));
}
public async Task SystemTestAsync(int approachId
, int orderQuantity
, int maxBucketSize
, long throughput
, int seed
, double arrivalRate
, long simulationEnd)
{
ResultContext ctxResult = ResultContext.GetContext(resultCon: testResultCtxString);
ProductionDomainContext masterCtx = ProductionDomainContext.GetContext(testCtxString);
DataGeneratorContext dataGenCtx = DataGeneratorContext.GetContext(testGeneratorCtxString);
var approach = ApproachRepository.GetApproachById(dataGenCtx, approachId);
var generator = new MainGenerator();
await Task.Run(() =>
generator.StartGeneration(approach, masterCtx, ctxResult));
var simContext = new AgentSimulation(DBContext: masterCtx, messageHub: new ConsoleHub());
var simConfig = ArgumentConverter.ConfigurationConverter(ctxResult, 1);
//LogConfiguration.LogTo(TargetTypes.Debugger, TargetNames.LOG_AGENTS, LogLevel.Trace, LogLevel.Trace);
LogConfiguration.LogTo(TargetTypes.Debugger, TargetNames.LOG_AGENTS, LogLevel.Info, LogLevel.Info);
//LogConfiguration.LogTo(TargetTypes.Debugger, TargetNames.LOG_AGENTS, LogLevel.Debug, LogLevel.Debug);
//LogConfiguration.LogTo(TargetTypes.Debugger, CustomLogger.PRIORITY, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.File, CustomLogger.SCHEDULING, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.File, CustomLogger.DISPOPRODRELATION, LogLevel.Debug, LogLevel.Debug);
//LogConfiguration.LogTo(TargetTypes.Debugger, CustomLogger.PROPOSAL, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.Debugger, CustomLogger.INITIALIZE, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.Debugger, CustomLogger.JOB, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.File, CustomLogger.ENQUEUE, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.Debugger, CustomLogger.JOBSTATE, LogLevel.Warn, LogLevel.Warn);
//LogConfiguration.LogTo(TargetTypes.File, TargetNames.LOG_AKKA, LogLevel.Trace, LogLevel.Trace);
//LogConfiguration.LogTo(TargetTypes.Debugger, TargetNames.LOG_AKKA, LogLevel.Warn);
var dataGenSim = new DB.GeneratorModel.Simulation();
dataGenSim.ApproachId = approachId;
dataGenSim.StartTime = DateTime.Now;
await Task.Run(() =>
{
dataGenCtx.Simulations.AddRange(dataGenSim);
dataGenCtx.SaveChanges();
});
// update customized Configuration
simConfig.AddOption(new DBConnectionString(testResultCtxString));
simConfig.ReplaceOption(new TimeConstraintQueueLength(480));
simConfig.ReplaceOption(new OrderArrivalRate(value: arrivalRate));
simConfig.ReplaceOption(new OrderQuantity(value: orderQuantity));
simConfig.ReplaceOption(new EstimatedThroughPut(value: throughput));
simConfig.ReplaceOption(new TimePeriodForThroughputCalculation(value: 2880));
simConfig.ReplaceOption(new Seed(value: seed));
simConfig.ReplaceOption(new SettlingStart(value: 0));
simConfig.ReplaceOption(new SimulationEnd(value: simulationEnd));
simConfig.ReplaceOption(new SaveToDB(value: true));
simConfig.ReplaceOption(new MaxBucketSize(value: maxBucketSize));
simConfig.ReplaceOption(new SimulationNumber(value: dataGenSim.Id));
simConfig.ReplaceOption(new DebugSystem(value: true));
simConfig.ReplaceOption(new WorkTimeDeviation(0.0));
// anpassen der Lieferzeiten anhand der Erwarteten Durchlaufzeit.
simConfig.ReplaceOption(new MinDeliveryTime(80));
simConfig.ReplaceOption(new MaxDeliveryTime(150));
await Task.Run(() =>
ArgumentConverter.ConvertBackAndSave(ctxResult, simConfig, dataGenSim.Id));
var simulation = await simContext.InitializeSimulation(configuration : simConfig);
if (simulation.IsReady())
{
// Start simulation
var sim = simulation.RunAsync();
simContext.StateManager.ContinueExecution(simulation);
await sim;
dataGenSim.FinishTime = DateTime.Now;
dataGenSim.FinishedSuccessfully = sim.IsCompletedSuccessfully;
await Task.Run(() =>
dataGenCtx.SaveChanges());
System.Diagnostics.Debug.WriteLine("################################# Simulation has finished with number " + dataGenSim.Id);
Assert.True(condition: sim.IsCompleted);
}
}
public void SetInput()
{
var success = true;
var iterations = 1;
for (var i = 0; i < iterations; i++)
{
var usePresetSeed = true;
var rng = new Random();
int seed = usePresetSeed ? 2083793265 : rng.Next();
var generatorDbCtx = DataGeneratorContext.GetContext(testGeneratorCtxString);
var approach = new Approach()
{
CreationDate = DateTime.Now,
Seed = seed
};
//Limit für Lambda und Anzahl Bearbeitungsstationen jeweils 100
var individualMachiningTime = true;
approach.TransitionMatrixInput = new TransitionMatrixInput
{
DegreeOfOrganization = 0.13,
Lambda = 1.3,
InfiniteTools = true,
ExtendedTransitionMatrix = true,
GeneralMachiningTimeParameterSet = individualMachiningTime ? null : new MachiningTimeParameterSet
{
MeanMachiningTime = 15,
VarianceMachiningTime = 5
},
WorkingStations = new List <WorkingStationParameterSet>()
{
new WorkingStationParameterSet()
{
MachiningTimeParameterSet = !individualMachiningTime ? null : new MachiningTimeParameterSet
{
MeanMachiningTime = 1, VarianceMachiningTime = 0
},
ResourceCount = 10,
ToolCount = 1,
SetupTime = 1,
OperatorCount = 0
},
new WorkingStationParameterSet()
{
MachiningTimeParameterSet = !individualMachiningTime ? null : new MachiningTimeParameterSet
{
MeanMachiningTime = 1, VarianceMachiningTime = 0
},
ResourceCount = 10,
ToolCount = 1,
SetupTime = 1,
OperatorCount = 0
},
new WorkingStationParameterSet()
{
MachiningTimeParameterSet = !individualMachiningTime ? null : new MachiningTimeParameterSet
{
MeanMachiningTime = 1, VarianceMachiningTime = 0
},
ResourceCount = 10,
ToolCount = 1,
SetupTime = 1,
OperatorCount = 0
},
new WorkingStationParameterSet()
{
MachiningTimeParameterSet = !individualMachiningTime ? null : new MachiningTimeParameterSet
{
MeanMachiningTime = 1, VarianceMachiningTime = 0
},
ResourceCount = 10,
ToolCount = 1,
SetupTime = 1,
OperatorCount = 0
},
new WorkingStationParameterSet()
{
MachiningTimeParameterSet = !individualMachiningTime ? null : new MachiningTimeParameterSet
{
MeanMachiningTime = 1, VarianceMachiningTime = 0
},
ResourceCount = 10,
ToolCount = 1,
SetupTime = 1,
OperatorCount = 0
},
new WorkingStationParameterSet()
{
MachiningTimeParameterSet = !individualMachiningTime ? null : new MachiningTimeParameterSet
{
MeanMachiningTime = 1, VarianceMachiningTime = 0
},
ResourceCount = 10,
ToolCount = 1,
SetupTime = 1,
OperatorCount = 0
},
new WorkingStationParameterSet()
{
MachiningTimeParameterSet = !individualMachiningTime ? null : new MachiningTimeParameterSet
{
MeanMachiningTime = 1, VarianceMachiningTime = 0
},
ResourceCount = 10,
ToolCount = 1,
SetupTime = 1,
OperatorCount = 0
},
new WorkingStationParameterSet()
{
MachiningTimeParameterSet = !individualMachiningTime ? null : new MachiningTimeParameterSet
{
MeanMachiningTime = 1, VarianceMachiningTime = 0
},
ResourceCount = 10,
ToolCount = 1,
SetupTime = 1,
OperatorCount = 0
},
new WorkingStationParameterSet()
{
MachiningTimeParameterSet = !individualMachiningTime ? null : new MachiningTimeParameterSet
{
MeanMachiningTime = 1, VarianceMachiningTime = 0
},
ResourceCount = 10,
ToolCount = 1,
SetupTime = 1,
OperatorCount = 0
},
new WorkingStationParameterSet()
{
MachiningTimeParameterSet = !individualMachiningTime ? null : new MachiningTimeParameterSet
{
MeanMachiningTime = 1, VarianceMachiningTime = 0
},
ResourceCount = 10,
ToolCount = 1,
SetupTime = 1,
OperatorCount = 0
}
}
};
//Nebenbedingung lautet, dass Fertigungstiefe mindestens 1 sein muss, es macht aber wenig Sinn, wenn sie gleich 1 ist, da es dann keine Fertigungen gibt
//-> Anpassung der Nebenbedingung: Fertigungstiefe muss mindestens 2 sein
//KG und MV nicht größer 5; FT nicht größer 20; Anzahl Endprodukte nicht größer 50
var randomGeneratedInputValues = false;
double?doubleNull = null;
approach.ProductStructureInput = new ProductStructureInput
{
EndProductCount = !randomGeneratedInputValues ? 1000 : rng.Next(9) + 2,
DepthOfAssembly = !randomGeneratedInputValues ? 2 : rng.Next(10) + 1,
ComplexityRatio = !randomGeneratedInputValues ? 1.0 : rng.NextDouble() + 1,
ReutilisationRatio = !randomGeneratedInputValues ? 1.0 : rng.NextDouble() + 1,
MeanIncomingMaterialAmount = 1,
StdDevIncomingMaterialAmount = 0.01,
MeanWorkPlanLength = approach.TransitionMatrixInput.ExtendedTransitionMatrix ? doubleNull : 3.0,
VarianceWorkPlanLength = approach.TransitionMatrixInput.ExtendedTransitionMatrix ? doubleNull : 1.0
};
//_testOutputHelper.WriteLine(approach.ProductStructureInput.ToString());
approach.BomInput = new BillOfMaterialInput
{
RoundEdgeWeight = true,
WeightEpsilon = 0.001m
};
generatorDbCtx.Approaches.AddRange(approach);
generatorDbCtx.SaveChanges();
System.Diagnostics.Debug.WriteLine("################################# Generated test data have the approach id of " + approach.Id);
}
Assert.True(success);
}
