public async Task DeleteCycleStep(string cycleStepId)
{
CycleStep cycleStepToDelete = unitOfWork.GetById <CycleStep>(cycleStepId);
await unitOfWork.DeleteWhere <CycleStep>(x => x.Id == cycleStepId);
await UpdateStepNumbersOnDelete(cycleStepToDelete);
}
public async Task CreateOrUpdateCycleStep(CycleStepItemViewModel cycleStepItemViewModel)
{
CycleStep cycleStepToInsertOrUpdate;
if (cycleStepItemViewModel.IsNew)
{
cycleStepToInsertOrUpdate = new CycleStep();
SynthesisCycle synthesisCycle = unitOfWork.GetById <SynthesisCycle>(cycleStepItemViewModel.SynthesisCycleId);
cycleStepToInsertOrUpdate.SynthesisCycle = synthesisCycle;
await MapCycleStepItemToCycleStep(cycleStepItemViewModel, cycleStepToInsertOrUpdate);
}
else
{
cycleStepToInsertOrUpdate = await unitOfWork.GetAll <CycleStep>()
.Include(x => x.SynthesisCycle)
.Include(x => x.HardwareFunction)
.SingleAsync(x => x.Id == cycleStepItemViewModel.CycleStepId);
await MapCycleStepItemToCycleStep(cycleStepItemViewModel, cycleStepToInsertOrUpdate);
}
unitOfWork.InsertOrUpdate(cycleStepToInsertOrUpdate);
unitOfWork.Commit();
if (cycleStepItemViewModel.IsNew)
{
await UpdateStepNumbersOnInsert(cycleStepItemViewModel, cycleStepToInsertOrUpdate);
}
}
private bool IsCycleStepApplicable(char nucleotide, CycleStep cycleStep)
{
bool isCycleStepApplicable = (nucleotide == 'A' && cycleStep.A) ||
(nucleotide == 'C' && cycleStep.C) ||
(nucleotide == 'G' && cycleStep.G) ||
(nucleotide == 'T' && cycleStep.T);
return(isCycleStepApplicable);
}
public CycleStep CreateCycleStep()
{
CycleStep cycleStep = new CycleStep()
{
Number = 1,
StepTime = 3,
SynthesisCycle = CreateSynthesisCycle(),
HardwareFunction = CreateHardwareFunction()
};
return(GetOrCreate(() => cycleStep));
}
private async Task UpdateStepNumbersOnDelete(CycleStep cycleStepToDelete)
{
IEnumerable <CycleStep> cycleSteps = await unitOfWork.GetAll <CycleStep>()
.Include(x => x.SynthesisCycle)
.Include(x => x.HardwareFunction)
.Where(x => x.SynthesisCycleId == cycleStepToDelete.SynthesisCycleId &&
x.Number > cycleStepToDelete.Number)
.OrderBy(x => x.Number)
.ToListAsync();
foreach (CycleStep cycleStep in cycleSteps)
{
cycleStep.Number--;
}
unitOfWork.Commit();
}
public async Task CreateOrUpdateSynthesisCycle(SynthesisCycleItemViewModel synthesisCycleItemViewModel)
{
SynthesisCycle synthesisCycle;
if (string.IsNullOrWhiteSpace(synthesisCycleItemViewModel.Id))
{
var currentPrincipal = identityStorage.GetPrincipal();
User currentUser = unitOfWork.GetById <User>(currentPrincipal.UserId);
synthesisCycle = new SynthesisCycle();
synthesisCycle.Name = synthesisCycleItemViewModel.Name;
synthesisCycle.User = currentUser;
SynthesisCycle defaultSynthesisCycle = await unitOfWork.GetAll <SynthesisCycle>()
.Include(x => x.CycleSteps)
.Include(x => x.CycleSteps.Select(y => y.HardwareFunction))
.SingleAsync(x => x.UserId == null);
foreach (CycleStep defaultCycleStep in defaultSynthesisCycle.CycleSteps)
{
CycleStep newCycleStep = new CycleStep();
newCycleStep.Number = defaultCycleStep.Number;
newCycleStep.StepTime = defaultCycleStep.StepTime;
newCycleStep.A = defaultCycleStep.A;
newCycleStep.G = defaultCycleStep.G;
newCycleStep.C = defaultCycleStep.C;
newCycleStep.T = defaultCycleStep.T;
newCycleStep.Six = defaultCycleStep.Six;
newCycleStep.Seven = defaultCycleStep.Seven;
newCycleStep.SafeStep = defaultCycleStep.SafeStep;
newCycleStep.HardwareFunction = defaultCycleStep.HardwareFunction;
synthesisCycle.CycleSteps.Add(newCycleStep);
}
}
else
{
synthesisCycle = await unitOfWork.GetAll <SynthesisCycle>().Include(x => x.User).SingleAsync(x => x.Id == synthesisCycleItemViewModel.Id);
synthesisCycle.Name = synthesisCycleItemViewModel.Name;
}
unitOfWork.InsertOrUpdate(synthesisCycle);
unitOfWork.Commit();
}
public void NotifyStep(CycleStep step)
{
string board = "";
int n = Board.B.N;
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < n; ++j)
{
int idx = i * n + j;
Being b = Board.B.Get(idx);
char mark = ' ';
if (b != null)
{
switch (b.Health)
{
case Being.HealthStatus.HEALTHY:
mark = 'H';
break;
case Being.HealthStatus.IMUNE:
mark = 'I';
break;
case Being.HealthStatus.INFECTED:
mark = 'X';
break;
case Being.HealthStatus.PSEUDOIMUNE:
mark = 'P';
break;
}
}
board += mark;
}
board += '\n';
}
string msg = string.Format(
"<color=blue>Step {0} =></color> H:{1} I:{2} P:{3} X:{4} [i:{5} d:{6} c:{7} b:{8}]",
step.num, step.healthies, step.imunes, step.pseudoimunes, step.infected,
step.infections, step.agedeads, step.casualties, step.newborns
);
Debug.Log(board + "\n" + msg);
}
void UpdateInfo(CycleStep step)
{
textStepNum.text = "Passo: " + step.num;
textTotalHealthy.text = step.healthies + " saudáveis.";
textTotalImunes.text = step.imunes + " imunes.";
textTotalInfection.text = step.infected + " infectados.";
textTotalPseudo.text = step.pseudoimunes + " pseudoimunes.";
textTotalGraves.text = step.dead + " mortos.";
textStepInfection.text = step.infections + " novos infectados.";
textStepDeadbyAge.text = step.agedeads + " mortos por idade.";
textStepCasualties.text = step.casualties + " mortos por acidente.";
textStepBirths.text = step.newborns + " novos nascidos.";
textInfectionChances.text = string.Format("Chances de infecção: {0}%", config.sliderInfectionChance.slider.value);
textAccidentChances.text = string.Format("Chances de acidentes: {0}%", config.sliderAccidentChance.slider.value);
textBirthChances.text = string.Format("Chances de nascimentos: {0}%", config.sliderBirthChance.slider.value);
//textFrequency.text = string.Format("Frequência: {0} Hz", config.sliderFrequency.slider.value);
}
private void Process(DataRow row)
{
var step = row.State != null?StateToCycleStep(row.State) : CurrentToCycleStep(row.Current);
if (step != _currStep)
{
if (step != CycleStep.Rest)
{
if (_steps.Contains(step) && Math.Abs(row.Capacity) <= CapacityThreshold)
{
_cycleIndex += 1;
_steps.Clear();
}
_steps.Add(step);
}
_currStep = step;
}
if (_startDateTime == null)
{
_startDateTime = row.TestTime;
}
var dataPoint = new DataPoint
{
CycleStep = step,
CycleIndex = _cycleIndex,
Time = (row.TestTime - _startDateTime.Value).TotalSeconds,
Current = row.Current,
Voltage = row.Voltage,
Capacity = row.Capacity,
Energy = row.Capacity * row.Voltage,
Power = row.Current * row.Voltage,
Temperature = row.Temperature
};
Push(_currentChannelIndex, dataPoint);
}
private string GetCycleStepApiUrl(CycleStep cycleStep, char nucleotide, IEnumerable <HardwareFunction> bAndTetToColFunctions)
{
string cycleStepApiUrl = cycleStep.HardwareFunction.ApiUrl;
if (cycleStep.HardwareFunction.FunctionType == HardwareFunctionType.BAndTetToCol)
{
switch (nucleotide)
{
case 'A':
cycleStepApiUrl = bAndTetToColFunctions
.Single(x => x.FunctionType == HardwareFunctionType.AAndTetToCol)
.ApiUrl;
break;
case 'C':
cycleStepApiUrl = bAndTetToColFunctions
.Single(x => x.FunctionType == HardwareFunctionType.CAndTetToCol)
.ApiUrl;
break;
case 'T':
cycleStepApiUrl = bAndTetToColFunctions
.Single(x => x.FunctionType == HardwareFunctionType.TAndTetToCol)
.ApiUrl;
break;
case 'G':
cycleStepApiUrl = bAndTetToColFunctions
.Single(x => x.FunctionType == HardwareFunctionType.GAndTetToCol)
.ApiUrl;
break;
}
}
return(cycleStepApiUrl);
}
private async Task MapCycleStepItemToCycleStep(CycleStepItemViewModel cycleStepItemViewModel, CycleStep cycleStep)
{
cycleStep.Number = cycleStepItemViewModel.StepNumber != 0 ? cycleStepItemViewModel.StepNumber : 1;
cycleStep.StepTime = cycleStepItemViewModel.StepTime;
cycleStep.A = cycleStepItemViewModel.A;
cycleStep.G = cycleStepItemViewModel.G;
cycleStep.C = cycleStepItemViewModel.C;
cycleStep.T = cycleStepItemViewModel.T;
cycleStep.T = cycleStepItemViewModel.T;
cycleStep.Six = cycleStepItemViewModel.Six;
cycleStep.Seven = cycleStepItemViewModel.Seven;
cycleStep.SafeStep = cycleStepItemViewModel.SafeStep;
if (string.IsNullOrWhiteSpace(cycleStepItemViewModel.HardwareFunction?.Id))
{
cycleStep.HardwareFunction = await unitOfWork.GetAll <HardwareFunction>()
.SingleAsync(x => x.FunctionType == HardwareFunctionType.BAndTetToCol);
}
else if (cycleStep.HardwareFunctionId != cycleStepItemViewModel.HardwareFunction.Id)
{
cycleStep.HardwareFunction = unitOfWork.GetById <HardwareFunction>(cycleStepItemViewModel.HardwareFunction.Id);
}
}
private async Task UpdateStepNumbersOnInsert(CycleStepItemViewModel cycleStepItemViewModel, CycleStep cycleStepToInsertOrUpdate)
{
bool cycleStepWithTheSameNumberExists = await unitOfWork.GetAll <CycleStep>()
.CountAsync(x => x.SynthesisCycleId == cycleStepItemViewModel.SynthesisCycleId && x.Number == cycleStepToInsertOrUpdate.Number) > 1;
if (cycleStepWithTheSameNumberExists)
{
IEnumerable <CycleStep> cycleSteps = await unitOfWork.GetAll <CycleStep>()
.Include(x => x.SynthesisCycle)
.Include(x => x.HardwareFunction)
.Where(x => x.SynthesisCycleId == cycleStepItemViewModel.SynthesisCycleId &&
x.Number >= cycleStepToInsertOrUpdate.Number && x.Id != cycleStepToInsertOrUpdate.Id)
.OrderBy(x => x.Number)
.ToListAsync();
foreach (CycleStep cycleStep in cycleSteps)
{
cycleStep.Number++;
}
unitOfWork.Commit();
}
}
public void NotifyStep(CycleStep step)
{
UpdateInfo(step);
}
private void Process(DataRow row)
{
if (_prev != null && _prev.StepIndex != row.StepIndex && _isChargeHappened && _isDischargeHappened)
{
_cycleIndex++;
_isChargeHappened = false;
_isDischargeHappened = false;
}
if (_startDateTime == null)
{
_startDateTime = row.DateTime;
}
CycleStep cycleStep = StepNameToCycleStep(row.StateCode);
if (_prev != null && _prev.StepIndex != row.StepIndex)
{
if (cycleStep == CycleStep.ChargeCC || cycleStep == CycleStep.ChargeCV)
{
_isChargeHappened = true;
}
else if (cycleStep == CycleStep.Discharge)
{
_isDischargeHappened = true;
}
}
DataPoint dataPoint = new DataPoint
{
CycleIndex = _cycleIndex,
CycleStep = cycleStep,
Time = (row.DateTime - _startDateTime.Value).TotalSeconds,
Current = 1000 * row.Current,
Voltage = row.Voltage,
Capacity = 1000 * row.Capacity,
Power = (1000 * row.Current) * row.Voltage,
Temperature = row.Temperature
};
if (cycleStep == CycleStep.ChargeCC || cycleStep == CycleStep.ChargeCV)
{
if (mWhEnergyMultiplier)
{
//milliwatt-hour (mWh) to Watt-hour (Wh), mWh = Wh * 1000
dataPoint.Energy = row.Energy / 1000;
}
else
{
dataPoint.Energy = row.Energy;
}
}
else if (cycleStep == CycleStep.Discharge)
{
if (mWhEnergyMultiplier)
{
//milliwatt-hour (mWh) to Watt-hour (Wh), mWh = Wh * 1000
dataPoint.DischargeEnergy = row.Energy / 1000;
}
else
{
dataPoint.DischargeEnergy = row.Energy;
}
}
Push(_currentChannelIndex, dataPoint);
_prev = row;
}
public void NotifyStep(CycleStep step)
{
UIRefresh();
}
