public static void CodeGen(this Visibilities visibility, CodeBuilder builder)
{
switch (visibility)
{
case Visibilities.Public:
builder.AppendToken("public");
break;
case Visibilities.Protected:
builder.AppendToken("protected");
break;
case Visibilities.Internal:
builder.AppendToken("internal");
break;
case Visibilities.ProtectedInternal:
builder.AppendToken("protected internal");
break;
case Visibilities.Private:
builder.AppendToken("private");
break;
default:
throw new ArgumentOutOfRangeException(nameof(visibility), visibility, null);
}
}
protected PropertyBuilder(Visibilities visibility, Type type, string name, bool setInConstructor = false)
{
Visibility = visibility;
Type = type;
Name = name;
SetInConstructor = setInConstructor;
}
public MethodBuilder(Visibilities visibility, string name, StatementBuilder body, Type returnType = null)
{
Visibility = visibility;
ReturnType = returnType;
Name = name;
Body = body;
}
private void UpdateVisibilities()
{
if (Config.WmtcMode)
{
Visibilities.NormalMode = Visibility.Collapsed;
}
else
{
Visibilities.NormalMode = Visibility.Visible;
Visibilities.SetVisibilityOfWmtcClass(String.Empty);
}
if (SelectedVehicle != null)
{
Visibilities.ShiftInput = Visibility.Visible;
if (BoundVehicleObject == null)
{
Visibilities.SetVisibilityOfGears(0);
}
else
{
Visibilities.SetVisibilityOfGears(TypeCast.ToInt(BoundVehicleObject.NumberOfGears));
if (Config.WmtcMode)
{
Visibilities.SetVisibilityOfWmtcClass(BoundVehicleObject.Class);
}
}
}
Visibilities = new BoundVisibilities(Visibilities);
}
public BlockLookup LookUp(Vector3i position)
{
byte block = GetBlock(position);
Visibilities visibility = _table.GetVisibility(block);
return(new BlockLookup(block, visibility));
}
void IPolicyConfigControl.ReadFromConfig(PolicyConfig config)
{
FieldConfig controlConfig = config.FieldConfig;
Visibilities.Bind(controlConfig.VisibilitiesToCheck);
SummaryDocumentationTagCheckBox.Checked = controlConfig.SummaryDocumentationRequired;
}
public SubsidiaryCardViewModel(IEventAggregator eventAggregator, EmployeeDataGridViewModel advisorsGrid,
Visibilities visibilities) : base(
eventAggregator, Screens.SubsidiaryEditor, visibilities)
{
this.AdvisorsGrid = advisorsGrid;
this.AdvisorsGrid.IsCompact = true;
this.AdvisorsGrid.DisplaySelectionColumn = false;
}
void IPolicyConfigControl.WriteToConfig(PolicyConfig config)
{
FieldConfig controlConfig = config.FieldConfig;
controlConfig.VisibilitiesToCheck = Visibilities.GetVisibilites();
controlConfig.SummaryDocumentationRequired = SummaryDocumentationTagCheckBox.Checked;
}
public ClothDataGridViewModel(IEventAggregator eventAggregator, ClothInstanceCardViewModel card, IModel model,
DeleteDialogViewModel removeDialog, Visibilities visibilities) : base(eventAggregator, card, null,
removeDialog,
Screens.About, visibilities)
{
_eventAggregator = eventAggregator;
_model = model;
}
void IPolicyConfigControl.WriteToConfig(PolicyConfig config)
{
ClassConfig controlConfig = GetConfig(config);
controlConfig.VisibilitiesToCheck = Visibilities.GetVisibilites();
controlConfig.GenericParameterDocumentationRequired = GenericParametersOptionCheckBox.Checked;
controlConfig.SampleDocumentationRequired = SampleDocumentationTagCheckBox.Checked;
controlConfig.SummaryDocumentationRequired = SummaryDocumentationTagCheckBox.Checked;
}
void IPolicyConfigControl.ReadFromConfig(PolicyConfig config)
{
ClassConfig controlConfig = GetConfig(config);
Visibilities.Bind(controlConfig.VisibilitiesToCheck);
GenericParametersOptionCheckBox.Checked = controlConfig.GenericParameterDocumentationRequired;
SampleDocumentationTagCheckBox.Checked = controlConfig.SampleDocumentationRequired;
SummaryDocumentationTagCheckBox.Checked = controlConfig.SummaryDocumentationRequired;
}
public CarCardViewModel(IEventAggregator eventAggregator, EmployeeDataGridViewModel driversGrid,
Visibilities visibilities) : base(eventAggregator, Screens.CarEditor, visibilities)
{
this.Drivers = driversGrid;
this.Drivers.DisplaySelectionColumn = false;
this.Drivers.IsCompact = true;
}
public FullPropertyBuilder(Visibilities visibility,
Type type,
string name,
StatementBuilder getterStatement,
StatementBuilder setterStatement)
: base(visibility, type, name)
{
GetterStatement = getterStatement;
SetterStatement = setterStatement;
}
void IPolicyConfigControl.WriteToConfig(PolicyConfig config)
{
EventConfig controlConfig = config.EventConfig;
controlConfig.VisibilitiesToCheck = Visibilities.GetVisibilites();
controlConfig.DocumentOverrides = OverridesOptionCheckBox.Checked;
controlConfig.ExplicitInterfaceEventDocumentationRequired = ExplicitOptionCheckBox.Checked;
controlConfig.InterfaceDeclarationDocumentationRequired = InterfaceOptionCheckBox.Checked;
controlConfig.SummaryDocumentationRequired = SummaryDocumentationTagCheckBox.Checked;
}
void IPolicyConfigControl.ReadFromConfig(PolicyConfig config)
{
EventConfig controlConfig = config.EventConfig;
Visibilities.Bind(controlConfig.VisibilitiesToCheck);
OverridesOptionCheckBox.Checked = controlConfig.DocumentOverrides;
ExplicitOptionCheckBox.Checked = controlConfig.ExplicitInterfaceEventDocumentationRequired;
InterfaceOptionCheckBox.Checked = controlConfig.InterfaceDeclarationDocumentationRequired;
SummaryDocumentationTagCheckBox.Checked = controlConfig.SummaryDocumentationRequired;
}
void IPolicyConfigControl.ReadFromConfig(PolicyConfig config)
{
DelegateConfig controlConfig = config.DelegateConfig;
Visibilities.Bind(controlConfig.VisibilitiesToCheck);
GenericParametersOptionCheckBox.Checked = controlConfig.GenericParameterDocumentationRequired;
ParametersOptionCheckBox.Checked = controlConfig.ParameterDocumentationRequired;
ReturnsDocumentationTagCheckBox.Checked = controlConfig.ResultDocumentationRequired;
SampleDocumentationTagCheckBox.Checked = controlConfig.SampleDocumentationRequired;
SummaryDocumentationTagCheckBox.Checked = controlConfig.SummaryDocumentationRequired;
}
void IPolicyConfigControl.WriteToConfig(PolicyConfig config)
{
DelegateConfig controlConfig = config.DelegateConfig;
controlConfig.VisibilitiesToCheck = Visibilities.GetVisibilites();
controlConfig.GenericParameterDocumentationRequired = GenericParametersOptionCheckBox.Checked;
controlConfig.ParameterDocumentationRequired = ParametersOptionCheckBox.Checked;
controlConfig.ResultDocumentationRequired = ReturnsDocumentationTagCheckBox.Checked;
controlConfig.SampleDocumentationRequired = SampleDocumentationTagCheckBox.Checked;
controlConfig.SummaryDocumentationRequired = SummaryDocumentationTagCheckBox.Checked;
}
public ConstantBuilder(Visibilities visibility,
Type type,
string name,
bool compileTimeConstant,
ExpressionBuilder expression)
{
Visibility = visibility;
Type = type;
Name = name;
CompileTimeConstant = compileTimeConstant;
Expression = expression;
}
/// <summary>
/// Конструктор, принимающий зависимости и параметры,
/// определяющее поведение таблицы (часто задаются в наследниках)
/// </summary>
/// <param name="eventAggregator"></param>
/// <param name="card"></param>
/// <param name="repo">Reposutory сущности</param>
/// <param name="removeDialog"></param>
/// <param name="editScreen">Значение перечисления экрана-редактора сущности</param>
/// <param name="visibilities"></param>
/// <param name="entityName">Название сущности (используется для экспорта в таблицу)</param>
/// <param name="displaySelectColumn">Показывать столбец выбора с флажками</param>
protected EntityGrid(IEventAggregator eventAggregator, TCard card, TRepository repo,
DeleteDialogViewModel removeDialog, Screens editScreen, Visibilities visibilities = null,
string entityName = "объекта",
bool displaySelectColumn = true)
{
this._card = card;
this._editScreen = editScreen;
this.EventAggregator = eventAggregator;
this.Repo = repo;
this.EntityName = entityName;
this.RemoveDialog = removeDialog;
this.DisplaySelectionColumn = displaySelectColumn;
this.BaseFilter = Builders <TEntity> .Filter.Empty;
this.Visibilities = visibilities;
}
void IPolicyConfigControl.WriteToConfig(PolicyConfig config)
{
MethodConfig controlConfig = config.MethodConfig;
controlConfig.VisibilitiesToCheck = Visibilities.GetVisibilites();
controlConfig.GenericParameterDocumentationRequired = GenericParametersOptionCheckBox.Checked;
controlConfig.ParameterDocumentationRequired = ParametersOptionCheckBox.Checked;
controlConfig.DocumentOverrides = OverridesOptionCheckBox.Checked;
controlConfig.ExplicitInterfaceMethodDocumentationRequired = ExplicitOptionCheckBox.Checked;
controlConfig.InterfaceDeclarationDocumentationRequired = InterfaceOptionCheckBox.Checked;
controlConfig.ResultDocumentationRequired = ReturnsDocumentationTagCheckBox.Checked;
controlConfig.SampleDocumentationRequired = SampleDocumentationTagCheckBox.Checked;
controlConfig.SummaryDocumentationRequired = SummaryDocumentationTagCheckBox.Checked;
}
void IPolicyConfigControl.ReadFromConfig(PolicyConfig config)
{
MethodConfig controlConfig = config.MethodConfig;
Visibilities.Bind(controlConfig.VisibilitiesToCheck);
GenericParametersOptionCheckBox.Checked = controlConfig.GenericParameterDocumentationRequired;
ParametersOptionCheckBox.Checked = controlConfig.ParameterDocumentationRequired;
OverridesOptionCheckBox.Checked = controlConfig.DocumentOverrides;
ExplicitOptionCheckBox.Checked = controlConfig.ExplicitInterfaceMethodDocumentationRequired;
InterfaceOptionCheckBox.Checked = controlConfig.InterfaceDeclarationDocumentationRequired;
ReturnsDocumentationTagCheckBox.Checked = controlConfig.ResultDocumentationRequired;
SampleDocumentationTagCheckBox.Checked = controlConfig.SampleDocumentationRequired;
SummaryDocumentationTagCheckBox.Checked = controlConfig.SummaryDocumentationRequired;
}
public ShellViewModel(IEventAggregator eventAggregator, Visibilities visibilities,
ConnectionLostDialogViewModel connectionLostDialog, IModel model, IScreenFactory factory)
{
Visibilities = visibilities;
eventAggregator.Subscribe(this);
//_employeeCard = employeeCard;
this._factory = factory;
this._connectionLostDialog = connectionLostDialog;
_model = model;
this.Handle(Screens.Login);
_paletteHelper = new PaletteHelper();
model.Connected += OnConnected;
model.ConnectionLost += OnConnectionLost;
}
public byte GetVisibilityCode()
{
byte code = 0;
if (Visibilities == null)
{
return(code);
}
foreach (DiscussCrowdType item in Enum.GetValues(typeof(DiscussCrowdType)))
{
if (Visibilities.Contains(item.ToString()))
{
code |= (byte)(0x01 << (byte)item);
}
}
return(code);
}
private void GenerateProperties(ModuleBuilder target,
Visibilities defaultVisibility,
IEnumerable <PapVariable> variables)
{
foreach (var variable in variables)
{
var defaultValueExpression = variable.Default != null
? PapEvalCodeParser.ConvertToExpression(variable.Default)
: null;
target.Properties.Add(new AutoPropertyBuilder(defaultVisibility,
TypeMapping.Map(variable.Type),
variable.Name,
defaultValueExpression)
{
Summary = variable.Documentation
});
}
}
public static void GenerateSerialCDExample(string simulatedLocation, string outputFolder)
{
var data = MeasurementData.LoadSimulatedPoints(simulatedLocation);
var cellSize = 1.0 / 3600.0 * Math.PI / 180.0;
var c = new GriddingConstants(data.VisibilitiesCount, 256, 8, 4, 512, (float)cellSize, 1, 0.0);
var metadata = Partitioner.CreatePartition(c, data.UVW, data.Frequencies);
var psfGrid = IDG.GridPSF(c, metadata, data.UVW, data.Flags, data.Frequencies);
var psf = FFT.BackwardFloat(psfGrid, c.VisibilitiesCount);
FFT.Shift(psf);
var corrKernel = PSF.CalcPaddedFourierCorrelation(psf, new Rectangle(0, 0, c.GridSize, c.GridSize));
Directory.CreateDirectory(outputFolder);
var reconstruction = new float[c.GridSize, c.GridSize];
var residualVis = data.Visibilities;
var totalSize = new Rectangle(0, 0, c.GridSize, c.GridSize);
var fastCD = new FastSerialCD(totalSize, psf);
var lambda = 0.50f * fastCD.MaxLipschitz;
var alpha = 0.2f;
for (int cycle = 0; cycle < 100; cycle++)
{
var dirtyGrid = IDG.Grid(c, metadata, residualVis, data.UVW, data.Frequencies);
var dirtyImage = FFT.BackwardFloat(dirtyGrid, c.VisibilitiesCount);
FFT.Shift(dirtyImage);
var gradients = Residuals.CalcGradientMap(dirtyImage, corrKernel, totalSize);
Tools.WriteToMeltCSV(Common.PSF.Cut(reconstruction), Path.Combine(outputFolder, "model_CD_" + cycle + ".csv"));
Tools.WriteToMeltCSV(gradients, Path.Combine(outputFolder, "gradients_CD_" + cycle + ".csv"));
fastCD.Deconvolve(reconstruction, gradients, lambda, alpha, 4);
FFT.Shift(reconstruction);
var xGrid = FFT.Forward(reconstruction);
FFT.Shift(reconstruction);
var modelVis = IDG.DeGrid(c, metadata, xGrid, data.UVW, data.Frequencies);
residualVis = Visibilities.Substract(data.Visibilities, modelVis, data.Flags);
}
}
private static ReconstructionInfo ReconstructGradientApprox(Data input, float[,] fullPsf, string folder, int cutFactor, int maxMajor, string dirtyPrefix, string xImagePrefix, StreamWriter writer, double objectiveCutoff, float epsilon)
{
var info = new ReconstructionInfo();
var psfCut = PSF.Cut(fullPsf, cutFactor);
var maxSidelobe = PSF.CalcMaxSidelobe(fullPsf, cutFactor);
var totalSize = new Rectangle(0, 0, input.c.GridSize, input.c.GridSize);
var psfBMap = psfCut;
var bMapCalculator = new PaddedConvolver(PSF.CalcPaddedFourierCorrelation(psfBMap, totalSize), new Rectangle(0, 0, psfBMap.GetLength(0), psfBMap.GetLength(1)));
var bMapCalculator2 = new PaddedConvolver(PSF.CalcPaddedFourierCorrelation(fullPsf, totalSize), new Rectangle(0, 0, fullPsf.GetLength(0), fullPsf.GetLength(1)));
var fastCD = new FastSerialCD(totalSize, psfCut);
var fastCD2 = new FastSerialCD(totalSize, psfCut);
fastCD2.ResetLipschitzMap(fullPsf);
FitsIO.Write(psfCut, folder + cutFactor + "psf.fits");
var lambda = LAMBDA_GLOBAL * fastCD.MaxLipschitz;
var lambdaTrue = (float)(LAMBDA_GLOBAL * PSF.CalcMaxLipschitz(fullPsf));
var xImage = new float[input.c.GridSize, input.c.GridSize];
var residualVis = input.visibilities;
DeconvolutionResult lastResult = null;
var firstTimeConverged = false;
var lastLambda = 0.0f;
for (int cycle = 0; cycle < maxMajor; cycle++)
{
Console.WriteLine("cycle " + cycle);
var dirtyGrid = IDG.GridW(input.c, input.metadata, residualVis, input.uvw, input.frequencies);
var dirtyImage = FFT.WStackIFFTFloat(dirtyGrid, input.c.VisibilitiesCount);
FFT.Shift(dirtyImage);
FitsIO.Write(dirtyImage, folder + dirtyPrefix + cycle + ".fits");
//calc data and reg penalty
var dataPenalty = Residuals.CalcPenalty(dirtyImage);
var regPenalty = ElasticNet.CalcPenalty(xImage, lambdaTrue, alpha);
var regPenaltyCurrent = ElasticNet.CalcPenalty(xImage, lambda, alpha);
info.lastDataPenalty = dataPenalty;
info.lastRegPenalty = regPenalty;
var maxDirty = Residuals.GetMax(dirtyImage);
var bMap = bMapCalculator.Convolve(dirtyImage);
FitsIO.Write(bMap, folder + dirtyPrefix + "bmap_" + cycle + ".fits");
var maxB = Residuals.GetMax(bMap);
var correctionFactor = Math.Max(maxB / (maxDirty * fastCD.MaxLipschitz), 1.0f);
var currentSideLobe = maxB * maxSidelobe * correctionFactor;
var currentLambda = Math.Max(currentSideLobe / alpha, lambda);
writer.Write(cycle + ";" + currentLambda + ";" + currentSideLobe + ";" + ";" + fastCD2.GetAbsMaxDiff(xImage, bMap, lambdaTrue, alpha) + ";" + dataPenalty + ";" + regPenalty + ";" + regPenaltyCurrent + ";");;
writer.Flush();
//check wether we can minimize the objective further with the current psf
var objectiveReached = (dataPenalty + regPenalty) < objectiveCutoff;
var minimumReached = (lastResult != null && lastResult.Converged && fastCD2.GetAbsMaxDiff(xImage, dirtyImage, lambdaTrue, alpha) < MAJOR_EPSILON && currentLambda == lambda);
if (lambda == lastLambda & !firstTimeConverged)
{
firstTimeConverged = true;
minimumReached = false;
}
if (!objectiveReached & !minimumReached)
{
//writer.Write(firstTimeConverged + ";");
//writer.Flush();
info.totalDeconv.Start();
if (!firstTimeConverged)
{
lastResult = fastCD.Deconvolve(xImage, bMap, currentLambda, alpha, 30000, epsilon);
}
else
{
bMap = bMapCalculator2.Convolve(dirtyImage);
//FitsIO.Write(bMap, folder + dirtyPrefix + "bmap_" + cycle + "_full.fits");
maxB = Residuals.GetMax(bMap);
correctionFactor = Math.Max(maxB / (maxDirty * fastCD2.MaxLipschitz), 1.0f);
currentSideLobe = maxB * maxSidelobe * correctionFactor;
currentLambda = Math.Max(currentSideLobe / alpha, lambdaTrue);
info.totalDeconv.Start();
lastResult = fastCD.Deconvolve(xImage, bMap, currentLambda, alpha, 30000, epsilon);
info.totalDeconv.Stop();
}
info.totalDeconv.Stop();
FitsIO.Write(xImage, folder + xImagePrefix + cycle + ".fits");
writer.Write(lastResult.Converged + ";" + lastResult.IterationCount + ";" + lastResult.ElapsedTime.TotalSeconds + "\n");
writer.Flush();
FFT.Shift(xImage);
var xGrid = FFT.Forward(xImage);
FFT.Shift(xImage);
var modelVis = IDG.DeGridW(input.c, input.metadata, xGrid, input.uvw, input.frequencies);
residualVis = Visibilities.Substract(input.visibilities, modelVis, input.flags);
}
else
{
writer.Write(false + ";0;0\n");
writer.Flush();
break;
}
lastLambda = currentLambda;
}
bMapCalculator.Dispose();
bMapCalculator2.Dispose();
return(info);
}
public ClothKindCardViewModel(IEventAggregator eventAggregator,
Visibilities visibilities) : base(eventAggregator, Screens.About, visibilities)
{
}
public static float[,] Reconstruct(Intracommunicator comm, DistributedData.LocalDataset local, GriddingConstants c, int maxCycle, float lambda, float alpha, int iterPerCycle = 1000, bool usePathDeconvolution = false)
{
var watchTotal = new Stopwatch();
var watchForward = new Stopwatch();
var watchBackward = new Stopwatch();
var watchDeconv = new Stopwatch();
watchTotal.Start();
var metadata = Partitioner.CreatePartition(c, local.UVW, local.Frequencies);
var patchSize = CalculateLocalImageSection(comm.Rank, comm.Size, c.GridSize, c.GridSize);
var totalSize = new Rectangle(0, 0, c.GridSize, c.GridSize);
//calculate psf and prepare for correlation in the Fourier space
var psf = CalculatePSF(comm, c, metadata, local.UVW, local.Flags, local.Frequencies);
Complex[,] PsfCorrelation = null;
var maxSidelobe = PSF.CalcMaxSidelobe(psf);
lambda = (float)(lambda * PSF.CalcMaxLipschitz(psf));
StreamWriter writer = null;
if (comm.Rank == 0)
{
FitsIO.Write(psf, "psf.fits");
Console.WriteLine("done PSF gridding ");
PsfCorrelation = PSF.CalcPaddedFourierCorrelation(psf, totalSize);
writer = new StreamWriter(comm.Size + "runtimestats.txt");
}
var deconvovler = new MPIGreedyCD(comm, totalSize, patchSize, psf);
var residualVis = local.Visibilities;
var xLocal = new float[patchSize.YEnd - patchSize.Y, patchSize.XEnd - patchSize.X];
for (int cycle = 0; cycle < maxCycle; cycle++)
{
if (comm.Rank == 0)
{
Console.WriteLine("cycle " + cycle);
}
var dirtyImage = ForwardCalculateB(comm, c, metadata, residualVis, local.UVW, local.Frequencies, PsfCorrelation, psf, maxSidelobe, watchForward);
var bLocal = GetImgSection(dirtyImage.Image, patchSize);
MPIGreedyCD.Statistics lastRun;
if (usePathDeconvolution)
{
var currentLambda = Math.Max(1.0f / alpha * dirtyImage.MaxSidelobeLevel, lambda);
lastRun = deconvovler.DeconvolvePath(xLocal, bLocal, currentLambda, 4.0f, alpha, 5, iterPerCycle, 2e-5f);
}
else
{
lastRun = deconvovler.Deconvolve(xLocal, bLocal, lambda, alpha, iterPerCycle, 1e-5f);
}
if (comm.Rank == 0)
{
WriteToFile(cycle, lastRun, writer);
if (lastRun.Converged)
{
Console.WriteLine("-----------------------------CONVERGED!!!!------------------------");
}
else
{
Console.WriteLine("-------------------------------not converged----------------------");
}
}
comm.Barrier();
if (comm.Rank == 0)
{
watchDeconv.Stop();
}
float[][,] totalX = null;
comm.Gather(xLocal, 0, ref totalX);
Complex[,] modelGrid = null;
if (comm.Rank == 0)
{
watchBackward.Start();
var x = new float[c.GridSize, c.GridSize];
StitchImage(totalX, x, comm.Size);
FitsIO.Write(x, "xImage_" + cycle + ".fits");
FFT.Shift(x);
modelGrid = FFT.Forward(x);
}
comm.Broadcast(ref modelGrid, 0);
var modelVis = IDG.DeGrid(c, metadata, modelGrid, local.UVW, local.Frequencies);
residualVis = Visibilities.Substract(local.Visibilities, modelVis, local.Flags);
}
writer.Close();
float[][,] gatherX = null;
comm.Gather(xLocal, 0, ref gatherX);
float[,] reconstructed = null;
if (comm.Rank == 0)
{
reconstructed = new float[c.GridSize, c.GridSize];;
StitchImage(gatherX, reconstructed, comm.Size);
}
return(reconstructed);
}
public ClothKindTreeViewModel(IEventAggregator eventAggregator, ClothKindCardViewModel card,
IModel model, DeleteDialogViewModel removeDialog, Visibilities visibilities)
: base(eventAggregator, card, model.ClothKinds, removeDialog, Screens.ClothKindEditor, visibilities)
{
_model = model;
this.EditableEntities = new ObservableCollection <ClothKind> {
Repo.GetById(0)
};
}
public CarDataGridViewModel(IEventAggregator eventAggregator, CarCardViewModel card,
DeleteDialogViewModel deleteDialog, IModel model, Visibilities visibilities)
: base(eventAggregator, card, model.Cars, deleteDialog, Screens.CarEditor, visibilities)
{
}
