/// <summary> /// Generates the Raw Data transform that produces our program's output. /// </summary> /// <returns>A transform configuration to be given to the API pipeline.</returns> public OutputConfig GenerateTransforms() { SimulatedPipeline.TransformManager.TransformList.Clear(); //Create the transforms for the first time. int sensorNum = 0; int channelNum = 0; for (int i = 0; i < SimulatedPipeline.TrignoSimulatedManager.Components.Count; i++) { if (SimulatedPipeline.TrignoSimulatedManager.Components[i].State == SelectionState.Allocated) { var tmp = SimulatedPipeline.TrignoSimulatedManager.Components[i]; sensorNum++; channelNum += tmp.Configuration.Channels.Count; } } if (TransformManager.TransformList.Count == 0) { var t = new TransformRawData(channelNum, channelNum); TransformManager.AddTransform(t); } //channel configuration happens each time transforms are armed. var t0 = TransformManager.TransformList[0]; var outconfig = new OutputConfig(); outconfig.NumChannels = channelNum; int channelIndex = 0; for (int i = 0; i < SimulatedPipeline.TrignoSimulatedManager.Components.Count; i++) { var component = SimulatedPipeline.TrignoSimulatedManager.Components[i]; if (component.State == SelectionState.Allocated) { for (int k = 0; k < component.Configuration.Channels.Count; k++) { var chin = component.SimChannels[k]; var chout = new ChannelTransform(chin.FrameInterval, chin.SamplesPerFrame, Units.VOLTS); TransformManager.AddInputChannel(t0, chin); TransformManager.AddOutputChannel(t0, chout); outconfig.MapOutputChannel(channelIndex, chout); channelIndex++; } } } return(outconfig); }
/// <summary> /// Generates the Raw Data transform that produces our program's output. /// </summary> /// <returns>A transform configuration to be given to the API pipeline.</returns> public OutputConfig GenerateTransforms() { // Clear the previous transforms should they exist. TransformManager.TransformList.Clear(); int channelNumber = 0; // Obtain the number of channels based on our sensors and their mode. for (int i = 0; i < BTPipeline.TrignoBtManager.Components.Count; i++) { if (BTPipeline.TrignoBtManager.Components[i].State == SelectionState.Allocated) { var tmp = BTPipeline.TrignoBtManager.Components[i]; BTCompConfig someconfig = tmp.Configuration as BTCompConfig; if (someconfig.IsComponentAvailable()) { channelNumber += BTPipeline.TrignoBtManager.Components[i].BtChannels.Count; } } } // Create the raw data transform, with an input and output channel for every // channel that exists in our setup. This transform applies the scaling to the raw // data from the sensor. var rawDataTransform = new TransformRawData(channelNumber, channelNumber); TransformManager.AddTransform(rawDataTransform); var fib = new FibonacciTransform(channelNumber, channelNumber); TransformManager.AddTransform(fib); var t0 = TransformManager.TransformList[0]; var fibonacciTransform = TransformManager.TransformList[1]; // The output configuration for the API to use. var outconfig = new OutputConfig(); outconfig.NumChannels = channelNumber; int channelIndex = 0; for (int i = 0; i < BTPipeline.TrignoBtManager.Components.Count; i++) { if (BTPipeline.TrignoBtManager.Components[i].State == SelectionState.Allocated) { BTCompConfig someconfig = BTPipeline.TrignoBtManager.Components[i].Configuration as BTCompConfig; if (someconfig.IsComponentAvailable()) { // For every channel in every sensor, we gather its sampling information (rate, interval, units) and create a // channel transform (an abstract channel used by transforms) from it. We then add the actual component's channel // as an input channel, and the channel transform as an output. // Finally, we map the channel counter and the output channel. This mapping is what determines the channel order in // the CollectionDataReady callback function. for (int k = 0; k < BTPipeline.TrignoBtManager.Components[i].BtChannels.Count; k++) { var chin = BTPipeline.TrignoBtManager.Components[i].BtChannels[k]; var chout = new ChannelTransform(chin.FrameInterval, chin.SamplesPerFrame, BTPipeline.TrignoBtManager.Components[i].BtChannels[k].Unit); TransformManager.AddInputChannel(rawDataTransform, chin); TransformManager.AddOutputChannel(rawDataTransform, chout); // now reroute the raw transform's data into the fibonacci transform var fibChin = chout; var fibChout = new ChannelTransform(fibChin.FrameInterval, fibChin.SamplesPerFrame, Units.VOLTS); TransformManager.AddInputChannel(fibonacciTransform, fibChin); TransformManager.AddOutputChannel(fibonacciTransform, fibChout); outconfig.MapOutputChannel(channelIndex, fibChout); channelIndex++; } } } } return(outconfig); }
internal IVariableDeclaration DeriveArrayVariable(ICollection <IStatement> addTo, BasicTransformContext context, string name, IList <IExpression[]> arraySize, IList <IVariableDeclaration[]> newIndexVar, IList <IList <IExpression> > indices = null, IList <IList <IExpression> > wildcardVars = null, bool useLiteralIndices = false, bool copyInitializer = false) { List <IExpression[]> newSizes = new List <IExpression[]>(); List <IVariableDeclaration[]> newIndexVars = new List <IVariableDeclaration[]>(); Type innerType = varType; if (indices != null) { // add wildcard variables to newIndexVars for (int i = 0; i < indices.Count; i++) { List <IExpression> sizeBracket = new List <IExpression>(); List <IVariableDeclaration> indexVarsBracket = new List <IVariableDeclaration>(); for (int j = 0; j < indices[i].Count; j++) { IExpression index = indices[i][j]; if (Recognizer.IsStaticMethod(index, new Func <int>(GateAnalysisTransform.AnyIndex))) { int replaceCount = 0; sizeBracket.Add(ReplaceIndexVars(context, sizes[i][j], indices, wildcardVars, ref replaceCount)); IVariableDeclaration v = indexVars[i][j]; if (wildcardVars != null) { v = Recognizer.GetVariableDeclaration(wildcardVars[newIndexVars.Count][indexVarsBracket.Count]); } else if (Recognizer.GetLoopForVariable(context, v) != null) { // v is already used in a parent loop. must generate a new variable. v = GenerateLoopVar(context, "_a"); } indexVarsBracket.Add(v); } } if (sizeBracket.Count > 0) { newSizes.Add(sizeBracket.ToArray()); newIndexVars.Add(indexVarsBracket.ToArray()); } innerType = Util.GetElementType(innerType); } } int literalIndexingDepth = 0; if (arraySize != null) { newSizes.AddRange(arraySize); if (useLiteralIndices) { literalIndexingDepth = newSizes.Count; } newIndexVars.AddRange(newIndexVar); } // innerType may not be an array type, so we create the new array type here instead of descending further. Type arrayType = CodeBuilder.MakeJaggedArrayType(innerType, newSizes); int indexingDepth = (indices == null) ? 0 : indices.Count; List <IList <IExpression> > replacements = new List <IList <IExpression> >(); if (indices != null) { replacements.AddRange(indices); } for (int i = indexingDepth; i < sizes.Count; i++) { if (replacements.Count == 0) { newSizes.Add(sizes[i]); if (indexVars.Count > i) { newIndexVars.Add(indexVars[i]); } } else { // must substitute references to indexVars with indices IExpression[] sizeBracket = new IExpression[sizes[i].Length]; IVariableDeclaration[] indexVarBracket = new IVariableDeclaration[sizes[i].Length]; IList <IExpression> replacementBracket = Builder.ExprCollection(); for (int j = 0; j < sizeBracket.Length; j++) { int replaceCount = 0; sizeBracket[j] = ReplaceIndexVars(context, sizes[i][j], replacements, wildcardVars, ref replaceCount); if (replaceCount > 0) { indexVarBracket[j] = GenerateLoopVar(context, "_a"); } else if (indexVars.Count > i) { indexVarBracket[j] = indexVars[i][j]; } if (indexVarBracket[j] != null) { replacementBracket.Add(Builder.VarRefExpr(indexVarBracket[j])); } } newSizes.Add(sizeBracket); newIndexVars.Add(indexVarBracket); replacements.Add(replacementBracket); } } IVariableDeclaration arrayvd = Builder.VarDecl(CodeBuilder.MakeValid(name), arrayType); Builder.NewJaggedArray(addTo, arrayvd, newIndexVars, newSizes, literalIndexingDepth); context.InputAttributes.CopyObjectAttributesTo(declaration, context.OutputAttributes, arrayvd); // cannot copy the initializer since it will have a different size. context.OutputAttributes.Remove <InitialiseTo>(arrayvd); context.OutputAttributes.Remove <InitialiseBackwardTo>(arrayvd); context.OutputAttributes.Remove <InitialiseBackward>(arrayvd); context.OutputAttributes.Remove <VariableInformation>(arrayvd); context.OutputAttributes.Remove <SuppressVariableFactor>(arrayvd); context.OutputAttributes.Remove <LoopContext>(arrayvd); context.OutputAttributes.Remove <Containers>(arrayvd); context.OutputAttributes.Remove <ChannelInfo>(arrayvd); context.OutputAttributes.Remove <IsInferred>(arrayvd); context.OutputAttributes.Remove <QueryTypeCompilerAttribute>(arrayvd); context.OutputAttributes.Remove <DerivMessage>(arrayvd); context.OutputAttributes.Remove <PointEstimate>(arrayvd); context.OutputAttributes.Remove <DescriptionAttribute>(arrayvd); context.OutputAttributes.Remove <MarginalPrototype>(arrayvd); VariableInformation vi = VariableInformation.GetVariableInformation(context, arrayvd); vi.IsStochastic = IsStochastic; vi.sizes = newSizes; vi.indexVars = newIndexVars; if (useLiteralIndices) { vi.LiteralIndexingDepth = literalIndexingDepth; } if (marginalPrototypeExpression != null) { // substitute indices in the marginal prototype expression vi.marginalPrototypeExpression = GetMarginalPrototypeExpression(context, marginalPrototypeExpression, replacements, wildcardVars); } InitialiseTo it = context.InputAttributes.Get <InitialiseTo>(declaration); if (it != null && copyInitializer) { // if original array is indexed [i,j][k,l][m,n] and indices = [*,*][3,*] then // initExpr2 = new PlaceHolder[wildcard0,wildcard1] { new PlaceHolder[wildcard2] { new PlaceHolder[newIndexVar] { initExpr[wildcard0,wildcard1][3,wildcard2] } } } IExpression initExpr = it.initialMessagesExpression; // add indices to the initialiser expression int wildcardBracket = 0; for (int depth = 0; depth < indexingDepth; depth++) { IList <IExpression> indexCollection = Builder.ExprCollection(); int wildcardCount = 0; for (int i = 0; i < indices[depth].Count; i++) { if (Recognizer.IsStaticMethod(indices[depth][i], new Func <int>(GateAnalysisTransform.AnyIndex))) { indexCollection.Add(wildcardVars[wildcardBracket][wildcardCount]); wildcardCount++; } else { indexCollection.Add(indices[depth][i]); } } if (indexCollection.Count > 0) { if (wildcardCount > 0) { wildcardBracket++; } initExpr = Builder.ArrayIndex(initExpr, indexCollection); } } // add array creates to the initialiser expression if (newIndexVar != null) { initExpr = MakePlaceHolderArrayCreate(initExpr, newIndexVar); } if (wildcardBracket > 0) { while (wildcardBracket > 0) { wildcardBracket--; initExpr = MakePlaceHolderArrayCreate(initExpr, vi.indexVars[wildcardBracket]); } } context.OutputAttributes.Set(arrayvd, new InitialiseTo(initExpr)); } ChannelTransform.setAllGroupRoots(context, arrayvd, false); return(arrayvd); }