private static double correct(bool unbiased, WeightType weightType, double sum, double weightSum, double squareSum)
{
if (unbiased)
{
if (weightType == WeightType.Automatic)
{
if (weightSum > 1 && weightSum.IsInteger(1e-8))
{
return(sum / (weightSum - 1));
}
return(sum / (weightSum - (squareSum / weightSum)));
}
else if (weightType == WeightType.Fraction)
{
/*
* if (Math.Abs(weightSum - 1.0) >= 1e-8)
* {
* throw new ArgumentException("An unbiased variance estimate"
+ " cannot be computed if weights do not sum to one. The"
+ " given weights sum up to " + squareSum, "weights");
+ }*/
return(sum / (weightSum - (squareSum / weightSum)));
}
else if (weightType == WeightType.Repetition)
{
return(sum / (weightSum - (squareSum / weightSum)));
}
}
return(sum / weightSum);
}
public bool readWeightTest(Behavior behavior)
{
_jetTestConnection = new TestJetbusConnection(behavior, ipaddress, "Administrator", "wtx", delegate { return(true); });
_dseObj = new DSEJet(_jetTestConnection, 100, update);
_dseObj.Connect(this.OnConnect, 100);
_dseObj.ProcessData.UpdateData(this, new EventArgs());
double expGross = 413.96;
double expNet = 463.96;
double expTare = 50;
WeightType readWeight = _dseObj.Weight;
if (readWeight.Gross == expGross && readWeight.Net == expNet && readWeight.Tare == expTare)
{
return(true);
}
else
{
return(false);
}
}
public void Clear()
{
f = g = h = 0;
type = GridType.Map;
parent = null;
weight = WeightType.Level0;
}
/// <summary>
/// 发送数据到U9
/// </summary>
/// <param name="count">扎数</param>
/// <param name="Weight">重量</param>
/// <param name="ExtensionField2">堆位</param>
/// <param name="ExtensionField3">过磅单号</param>
/// <param name="ShipmentNumber">采购单</param>
/// <param name="DepartmentCode">部门代码</param>
public static bool sendDate(int count, double Weight, string ExtensionField2, string ExtensionField3, string ShipmentNumber, string DepartmentCode)
{
try
{
LWU9WebReference.LooseWastePaperManagement_v001 lw = new EMEWEQUALITY.LWU9WebReference.LooseWastePaperManagement_v001();
string OrganizationID = Common.OrganizationID;//公司代号
LoosePaperTruckLoadU9Type TruckLoad = new LoosePaperTruckLoadU9Type();
WeightType wt = new WeightType();
wt.Value = Convert.ToDecimal(Weight);
WeightUnitType wut = WeightUnitType.kg;
Weight = (double)Weight / (double)1000;
TruckLoad.Count = count; //扎数
TruckLoad.Weight = Weight; //重量
TruckLoad.ExtensionField2 = ExtensionField2; //堆位
TruckLoad.ExtensionField3 = ExtensionField3; //过磅单号
TruckLoad.WorkshopMachineID = "201311111111";
TruckLoad.DepartmentCode = DepartmentCode; //部门代码
TruckLoad.BusinessDate = DateTime.Now;
TruckLoad.TruckLoadDocumentID = "10";
RequestHeaderType rht = new RequestHeaderType();
rht.SourceID = Common.SourceID;
lw.Url = Common.SendURL;
lw.RequestHeader = rht;//数据源（发起请求应用名）
LoosePaperContainerShareU9Type[] Distribution = new LoosePaperContainerShareU9Type[1];
LoosePaperContainerShareU9Type lpc = new LoosePaperContainerShareU9Type();
//必填
lpc.ContainerID = "30";
lpc.IsGettingShare = true;
lpc.PONumber = "20";
lpc.ShipmentNumber = ShipmentNumber;//采购单
lpc.UnloadPlatform = "备注";
lpc.Memo = "20.质检纸";
lpc.TypeOfWeighedWastePaper = TypeOfWeighedWastePaperType.BaleLocal;//纸种
lpc.TypeOfWeighedWastePaperSpecified = true;
Distribution[0] = lpc;
string DistributionMemo = "cs1";
System.Xml.XmlAttribute[] AnyAttr = new System.Xml.XmlAttribute[0];
lpc.AnyAttr = AnyAttr;
ReplyMessageType message = lw.RegisterLoosePaperDistribution(OrganizationID, TruckLoad, DistributionMemo, Distribution, AnyAttr);
if (message.ResultCode.ToString() == "Successful")
{
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return(false);
}
}
public void ClickClean()
{
startX = startY = targetX = targetY = 0;
alpha = 0;
openList.Clear();
closeList.Clear();
parentList.Clear();
startGrid = null;
endGrid = null;
startRect = null;
endRect = null;
curType = GridType.Map;
curColor = typeColor[(int)WeightType.Level0];
curWeight = WeightType.Level0;
for (int x = 0; x < row; x++)
{
for (int y = 0; y < colomn; y++)
{
grids[x, y].Clear();
grids[x, y].weight = (WeightType)MapData[x, y];
objs[x, y].image.color = typeColor[MapData[x, y]];
}
}
Debug.Log("Clean");
}
public int Update(int templateNo, string templateName, WeightType weightType, ReplaceType replaceType, int futuresCopies, double marketCapOpt, string benchmarkId, int userId)
{
var dbCommand = _dbHelper.GetStoredProcCommand(SP_Modify);
_dbHelper.AddInParameter(dbCommand, "@TemplateId", System.Data.DbType.Int32, templateNo);
_dbHelper.AddInParameter(dbCommand, "@TemplateName", System.Data.DbType.String, templateName);
_dbHelper.AddInParameter(dbCommand, "@Status", System.Data.DbType.Int32, (int)TemplateStatus.Normal);
_dbHelper.AddInParameter(dbCommand, "@WeightType", System.Data.DbType.Int32, (int)weightType);
_dbHelper.AddInParameter(dbCommand, "@ReplaceType", System.Data.DbType.Int32, (int)replaceType);
_dbHelper.AddInParameter(dbCommand, "@FuturesCopies", System.Data.DbType.Int32, futuresCopies);
_dbHelper.AddInParameter(dbCommand, "@MarketCapOpt", System.Data.DbType.Decimal, marketCapOpt);
_dbHelper.AddInParameter(dbCommand, "@BenchmarkId", System.Data.DbType.String, benchmarkId);
_dbHelper.AddInParameter(dbCommand, "@ModifiedDate", System.Data.DbType.DateTime, DateTime.Now);
_dbHelper.AddInParameter(dbCommand, "@CreatedUserId", System.Data.DbType.Int32, userId);
_dbHelper.AddReturnParameter(dbCommand, "@return", System.Data.DbType.Int32);
int ret = _dbHelper.ExecuteNonQuery(dbCommand);
int templateId = -1;
if (ret > 0)
{
templateId = (int)dbCommand.Parameters["@return"].Value;
}
return(templateId);
}
public void AddWeights(params WeightType[] additionalWeights)
{
WeightType[] newWeights = new WeightType[this.weights.Length + additionalWeights.Length];
this.weights.CopyTo(newWeights, 0);
additionalWeights.CopyTo(newWeights, this.weights.Length);
this.SetWeights(newWeights);
}
public IActionResult Create(int year, string month, int day, int foodId, int mealId)
{
// TODO PARSE TRY
var date = new DateTime(year, int.Parse(month), day);
ViewData["Date"] = date;
Food food = _calendarDatabase.Foods.Find(foodId);
Meal meal = _calendarDatabase.Meals.Find(mealId);
if (food == null || meal == null)
{
TempData["Error"] = "Wrong input";
return(Redirect(
string.Format("/calendarFood/add/{0}/{1}/{2}/{3}",
year, month, day, mealId)));
}
// check if already exist and then update it
CalendarFoodItem foodItem = _calendarDatabase.FoodItems.Where(cfi => cfi.CalendarDate.Date == date.Date && cfi.Meal.MealID == mealId && cfi.Food.FoodID == food.FoodID).SingleOrDefault();
string GramUnitName = "gram";
WeightType gram = _calendarDatabase.WeightTypes.Where(wt => wt.UnitName == GramUnitName).FirstOrDefault();
if (foodItem == null)
{
foodItem = new CalendarFoodItem()
{
Food = food,
Meal = meal,
Weight = decimal.ToInt32(food.Weight),
CalendarDate = date
};
_calendarDatabase.FoodItems.Add(foodItem);
}
else
{
foodItem.Weight += decimal.ToInt32(food.Weight);
}
_calendarDatabase.SaveChanges();
TempData["Success"] = "Created.";
return(Redirect(
string.Format("/calendarFood/add/{0}/{1}/{2}/{3}",
year, month, day, mealId)));
}
/// <summary>
/// Assigns measurement and measurement type.
/// </summary>
/// <param name="measurement"></param>
/// <param name="measurementType"></param>
internal void AssignMeasurement(double?measurement, WeightType measurementType)
{
if (measurement.HasValue)
{
//A non null value is being assigned for this type
_measurement = measurement;
_measurementType = measurementType;
}
else if ((measurement.HasValue == false) && (_measurementType == measurementType))
{
//The measurements are being cleared.
_measurement = null;
_measurementType = null;
}
}
private void initialize(IDensityKernel kernel, double[][] observations,
double[] weights, int[] repeats, double[,] smoothing)
{
if (smoothing == null)
{
smoothing = SilvermanRule(observations, weights, repeats);
}
if (kernel == null)
{
kernel = new GaussianKernel(Dimension);
}
this.kernel = kernel;
this.samples = observations;
this.smoothing = smoothing;
this.determinant = smoothing.Determinant();
this.weights = weights;
this.repeats = repeats;
this.chol = new CholeskyDecomposition(smoothing);
if (weights != null)
{
this.type = WeightType.Fraction;
this.numberOfSamples = samples.Length;
this.sumOfWeights = weights.Sum();
}
else if (repeats != null)
{
this.type = WeightType.Repetition;
this.numberOfSamples = repeats.Sum();
this.sumOfWeights = 1.0;
}
else
{
this.type = WeightType.None;
this.numberOfSamples = samples.Length;
this.sumOfWeights = 1.0;
}
this.mean = null;
this.variance = null;
this.covariance = null;
}
public static void ConvertToPounds(double weight, WeightType type)
{
switch (type)
{
case WeightType.GRAM:
{
double pounds = weight * 2.20462d;
double ounces = pounds - Math.Floor(pounds);
pounds -= ounces;
ounces *= 16;
Console.WriteLine("{0} lbs and {1} oz.", pounds, ounces);
break;
}
default:
throw new Exception("Weight type not supported");
}
}
public static string GetWeightType(WeightType weightType)
{
string weightTypeName = string.Empty;
switch (weightType)
{
case WeightType.ProportionalWeight:
weightTypeName = "比例权重";
break;
case WeightType.AmountWeight:
weightTypeName = "数量权重";
break;
default:
break;
}
return(weightTypeName);
}
private void initialize(double[] observations, double[] weights, int[] repeats, double?smoothing)
{
if (smoothing == null)
{
smoothing = SmoothingRule(observations, weights, repeats);
}
this.samples = observations;
this.weights = weights;
this.repeats = repeats;
this.smoothing = smoothing.Value;
if (weights != null)
{
this.type = WeightType.Fraction;
this.numberOfSamples = samples.Length;
this.sumOfWeights = weights.Sum();
this.constant = 1.0 / (Constants.Sqrt2PI * this.smoothing);
}
else if (repeats != null)
{
this.type = WeightType.Repetition;
this.numberOfSamples = repeats.Sum();
this.sumOfWeights = 1.0;
this.constant = 1.0 / (Constants.Sqrt2PI * this.smoothing * numberOfSamples);
}
else
{
this.type = WeightType.None;
this.numberOfSamples = samples.Length;
this.sumOfWeights = 1.0;
this.constant = 1.0 / (Constants.Sqrt2PI * this.smoothing * numberOfSamples);
}
this.mean = null;
this.variance = null;
}
public static WeightModel Create(WeightType weightType)
{
switch (weightType)
{
case WeightType.ExtraSmall:
return(new WeightModel(0, 1));
case WeightType.Small:
return(new WeightModel(1, 5));
case WeightType.Medium:
return(new WeightModel(5, 15));
case WeightType.Large:
return(new WeightModel(15, 30));
case WeightType.ExtraLarge:
return(new WeightModel(30, float.MaxValue));
default:
return(null);
}
}
/// <summary>
/// Defines the target font waght.
/// </summary>
/// <param name="weight"></param>
public FontWeightAttribute(WeightType weight)
{
switch (weight)
{
case WeightType.Thin: Weight = FontWeights.Thin; return;
case WeightType.ExtraLight: Weight = FontWeights.ExtraLight; return;
case WeightType.UltraLight: Weight = FontWeights.UltraLight; return;
case WeightType.Light: Weight = FontWeights.Light; return;
case WeightType.Normal: Weight = FontWeights.Normal; return;
case WeightType.Regular: Weight = FontWeights.Regular; return;
case WeightType.Medium: Weight = FontWeights.Medium; return;
case WeightType.DemiBold: Weight = FontWeights.DemiBold; return;
case WeightType.SemiBold: Weight = FontWeights.SemiBold; return;
case WeightType.Bold: Weight = FontWeights.Bold; return;
case WeightType.ExtraBold: Weight = FontWeights.ExtraBold; return;
case WeightType.UltraBold: Weight = FontWeights.UltraBold; return;
case WeightType.Black: Weight = FontWeights.Black; return;
case WeightType.Heavy: Weight = FontWeights.Heavy; return;
case WeightType.ExtraBlack: Weight = FontWeights.ExtraBlack; return;
case WeightType.UltraBlack: Weight = FontWeights.UltraBlack; return;
}
}
static void Main()
{
try
{
FreightRateService freightRateService = new FreightRateService();
FreightRateRequest freightRateRequest = new FreightRateRequest();
RequestType request = new RequestType();
String[] requestOption = { "RateChecking Option" };
request.RequestOption = requestOption;
freightRateRequest.Request = request;
/** ****************ShipFrom******************************* */
ShipFromType shipFrom = new ShipFromType();
AddressType shipFromAddress = new AddressType();
String[] shipFromAddressLines = { "ShipFrom address" };
shipFromAddress.AddressLine = shipFromAddressLines;
shipFromAddress.City = "ShipFrom city";
shipFromAddress.StateProvinceCode = "ShipFrom state province code";
shipFromAddress.PostalCode = "ShipFrom postal code";
shipFromAddress.CountryCode = "ShipFrom country code";
shipFrom.Address = shipFromAddress;
shipFrom.AttentionName = "ShipFrom attention name";
shipFrom.Name = "ShipFrom Name";
freightRateRequest.ShipFrom = shipFrom;
/** ****************ShipFrom******************************* */
/** ****************ShipTo*************************************** */
ShipToType shipTo = new ShipToType();
AddressType shipToAddress = new AddressType();
String[] shipToAddressLines = { "ShipTo address line" };
shipToAddress.AddressLine = shipToAddressLines;
shipToAddress.City = "ShipTo city";
shipToAddress.StateProvinceCode = "ShipTo state province code";
shipToAddress.PostalCode = "ShipTo postal code";
shipToAddress.CountryCode = "ShipTo country code";
shipTo.Address = shipToAddress;
shipTo.AttentionName = "ShipTo attention name";
shipTo.Name = "ShipTo Name";
freightRateRequest.ShipTo = shipTo;
/** ****************ShipTo*************************************** */
/** ***************PaymentInformationType************************* */
PaymentInformationType paymentInfo = new PaymentInformationType();
PayerType payer = new PayerType();
payer.AttentionName = "Payer attention name";
payer.Name = "Payer name";
payer.ShipperNumber = "Payer shipper number";
AddressType payerAddress = new AddressType();
String[] payerAddressLines = { "Payer address line" };
payerAddress.AddressLine = payerAddressLines;
payerAddress.City = "Payer city";
payerAddress.StateProvinceCode = "Payer state province code";
payerAddress.PostalCode = "Payer postal code";
payerAddress.CountryCode = "Payer country code";
payer.Address = payerAddress;
paymentInfo.Payer = payer;
RateCodeDescriptionType shipBillOption = new RateCodeDescriptionType();
shipBillOption.Code = "Ship bill option";
shipBillOption.Description = "Ship bill description";
paymentInfo.ShipmentBillingOption = shipBillOption;
freightRateRequest.PaymentInformation = paymentInfo;
/** ***************PaymentInformationType************************* */
//Below code use dummy data for referenced. Please update as required
/** ***************Service************************************** */
RateCodeDescriptionType service = new RateCodeDescriptionType();
service.Code = "309";
service.Description = "UPS Ground Freight";
freightRateRequest.Service = service;
/** ***************Service************************************** */
/** **************Commodity************************************* */
CommodityType commodity = new CommodityType();
CommodityValueType commValue = new CommodityValueType();
commValue.CurrencyCode = "USD";
commValue.MonetaryValue = "5670";
commodity.CommodityValue = commValue;
commodity.NumberOfPieces = "20";
RateCodeDescriptionType packagingType = new RateCodeDescriptionType();
packagingType.Code = "BAG";
packagingType.Description = "BAG";
commodity.PackagingType = packagingType;
WeightType weight = new WeightType();
UnitOfMeasurementType unitOfMeasurement = new UnitOfMeasurementType();
unitOfMeasurement.Code = "LBS";
unitOfMeasurement.Description = "Pounds";
weight.UnitOfMeasurement = unitOfMeasurement;
weight.Value = "200";
commodity.Weight = weight;
commodity.Description = "LCD TVS";
CommodityValueType commodityValue = new CommodityValueType();
commodityValue.CurrencyCode = "USD";
commodityValue.MonetaryValue = "100";
commodity.CommodityValue = commodityValue;
commodity.Description = "LCD TVS";
commodity.FreightClass = "60";
CommodityType[] commodityArray = { commodity };
freightRateRequest.Commodity = commodityArray;
/** **************Commodity************************************* */
/** **************HandlingUnitOne************************************* */
HandlingUnitType handUnitType = new HandlingUnitType();
handUnitType.Quantity = "1";
RateCodeDescriptionType rateCodeDescType = new RateCodeDescriptionType();
rateCodeDescType.Code = "SKD";
rateCodeDescType.Description = "SKID";
handUnitType.Type = rateCodeDescType;
freightRateRequest.HandlingUnitOne = handUnitType;
/** **************HandlingUnitOne************************************* */
UPSSecurity upss = new UPSSecurity();
UPSSecurityServiceAccessToken upsSvcToken = new UPSSecurityServiceAccessToken();
upsSvcToken.AccessLicenseNumber = "Your License Number";
upss.ServiceAccessToken = upsSvcToken;
UPSSecurityUsernameToken upsSecUsrnameToken = new UPSSecurityUsernameToken();
upsSecUsrnameToken.Username = "******";
upsSecUsrnameToken.Password = "******";
upss.UsernameToken = upsSecUsrnameToken;
freightRateService.UPSSecurityValue = upss;
System.Net.ServicePointManager.CertificatePolicy = new TrustAllCertificatePolicy();
Console.WriteLine(freightRateRequest);
FreightRateResponse freightRateResponse = freightRateService.ProcessFreightRate(freightRateRequest);
Console.WriteLine("Response code: " + freightRateResponse.Response.ResponseStatus.Code);
Console.WriteLine("Response description: " + freightRateResponse.Response.ResponseStatus.Description);
Console.ReadKey();
}
catch (System.Web.Services.Protocols.SoapException ex)
{
Console.WriteLine("");
Console.WriteLine("---------Freight Rate Web Service returns error----------------");
Console.WriteLine("---------\"Hard\" is user error \"Transient\" is system error----------------");
Console.WriteLine("SoapException Message= " + ex.Message);
Console.WriteLine("");
Console.WriteLine("SoapException Category:Code:Message= " + ex.Detail.LastChild.InnerText);
Console.WriteLine("");
Console.WriteLine("SoapException XML String for all= " + ex.Detail.LastChild.OuterXml);
Console.WriteLine("");
Console.WriteLine("SoapException StackTrace= " + ex.StackTrace);
Console.WriteLine("-------------------------");
Console.WriteLine("");
}
catch (System.ServiceModel.CommunicationException ex)
{
Console.WriteLine("");
Console.WriteLine("--------------------");
Console.WriteLine("CommunicationException= " + ex.Message);
Console.WriteLine("CommunicationException-StackTrace= " + ex.StackTrace);
Console.WriteLine("-------------------------");
Console.WriteLine("");
}
catch (Exception ex)
{
Console.WriteLine("");
Console.WriteLine("-------------------------");
Console.WriteLine(" General Exception= " + ex.Message);
Console.WriteLine(" General Exception-StackTrace= " + ex.StackTrace);
Console.WriteLine("-------------------------");
}
finally
{
Console.ReadKey();
}
}
public float GetWeight(WeightType t)
{
return(_weights[(int)t]);
}
public void SetWeight(WeightType t, float value)
{
_weights[(int)t] = value;
}
public static double Convert(double value, WeightType fromUnits, WeightType toUnits)
{
//Code here to convert units
}
/// <summary>
///
/// </summary>
/// <param name="dimensionality">Dimensionality (N) of the problem</param>
/// <param name="maxgen">Maximum number of generations that the system will run (needed for damping)</param>
/// <param name="lambda">Number of offspring</param>
/// <param name="mu">PopulationSize</param>
/// <param name="weightType">Weighting scheme (for 'selection'): logarithmic, equal, linear</param>
/// <param name="minSDs">minimum stdevs, last one will apply for all remaining axes</param>
/// <param name="initialSDs">initial stdevs, last one will apply for all remaining axes</param>
public CMAParams(
int dimensionality,
int maxgen,
int lambda,
int mu,
double[] minSDs,
double[] initialSDs,
WeightType weightType = WeightType.Logarithmic)
{
N = dimensionality;
MaxGen = maxgen;
if (lambda < 2)
{
this.Lambda = 4 + (int)(3.0 * Math.Log((double)N));
}
else
{
this.Lambda = (int)lambda;
}
_weightType = weightType;
if ((mu >= Lambda) || (mu < 1))
{
Mu = (int)Math.Floor(Lambda / 2.0);
}
else
{
Mu = (int)mu;
}
Weights = new double[Mu];
switch (weightType)
{
case WeightType.Equal:
for (int i = 0; i < Weights.Length; ++i)
{
Weights[i] = Mu - i;
}
break;
case WeightType.Linear:
Weights = Weights.Select(x => 1.0).ToArray();
break;
case WeightType.Logarithmic:
case WeightType.NotSet:
default:
for (int i = 0; i < Weights.Length; ++i)
{
Weights[i] = Math.Log(Mu + 1.0) - Math.Log(i + 1.0);
}
break;
}
/* Normalize weights and set mu_eff */
double sumw = Weights.Sum();
MuEff = sumw * sumw / Weights.Sum(x => x * x);
Weights = Weights.Select(x => x / sumw).ToArray();
/* set the others using Nikolaus logic. If you want to tweak, you can parameterize over these defaults */
MuCov = MuEff;
CCumSig = (MuEff + 2.0) / (N + MuEff + 3.0);
CCumCov = 4.0 / (N + 4);
double t1 = 2.0 / ((N + 1.4142) * (N + 1.4142));
double t2 = (2.0 * MuCov - 1.0) / ((N + 2.0) * (N + 2.0) + MuCov);
t2 = (t2 > 1) ? 1 : t2;
t2 = (1.0 / MuCov) * t1 + (1.0 - 1.0 / MuCov) * t2;
CCov = t2;
Damp = 1 + Math.Max(0.3, (1.0 - (double)N / (double)maxgen))
* (1.0 + 2.0 * Math.Max(0.0, Math.Sqrt((MuEff - 1.0) / (N + 1.0)) - 1.0)) /* limit sigma increase */
/ CCumSig;
if (minSDs == null)
{
minSDs = new double[N];
for (int i = 0; i < N; i++)
{
minSDs[i] = 0.0;
}
}
if (initialSDs == null)
{
initialSDs = new double[N];
for (int i = 0; i < N; i++)
{
initialSDs[i] = 0.3;
}
}
MinStdDevs = minSDs;
InitialStdDevs = initialSDs;
}
public VertexKey ownerID;//边的拥有者ID
public Edge(VertexKey ownerID, VertexKey targetID, WeightType weight) : base(targetID, weight)
{
this.ownerID = ownerID;
}
private CommodityType WriteSingleCommidityPackage(IShippable pak, bool ignoreDimensions)
{
decimal dGirth = 0;
decimal dLength = 0;
decimal dHeight = 0;
decimal dwidth = 0;
CommodityType commodity = new CommodityType();
CommodityValueType commValue = new CommodityValueType();
commodity.NumberOfPieces = pak.QuantityOfItemsInBox.ToString();
RateCodeDescriptionType packagingType = new RateCodeDescriptionType();
packagingType.Code = ((int)GlobalSettings.DefaultPackaging).ToString();
packagingType.Description = GlobalSettings.DefaultPackaging.ToString();
commodity.PackagingType = packagingType;
WeightType weight = new WeightType();
UnitOfMeasurementType unitOfMeasurement = new UnitOfMeasurementType();
unitOfMeasurement.Code = (pak.BoxWeightType == Hotcakes.Shipping.WeightType.Pounds ? "LBS" : "KGS");
unitOfMeasurement.Description = (pak.BoxWeightType == Hotcakes.Shipping.WeightType.Pounds ? "LBS" : "KGS");
weight.UnitOfMeasurement = unitOfMeasurement;
if (pak.BoxWeight > 0)
{
weight.Value = Math.Round(pak.BoxWeight, 1).ToString();
}
else
{
weight.Value = "1";
}
commodity.Weight = weight;
commodity.Description = "Weight";
commodity.FreightClass = GlobalSettings.FreightClass;
var dimensions = new List <DimensionAmount>();
if (pak.BoxLengthType == LengthType.Centimeters)
{
dimensions.Add(new DimensionAmount(Conversions.CentimetersToInches(pak.BoxLength)));
dimensions.Add(new DimensionAmount(Conversions.CentimetersToInches(pak.BoxWidth)));
dimensions.Add(new DimensionAmount(Conversions.CentimetersToInches(pak.BoxHeight)));
}
else
{
dimensions.Add(new DimensionAmount(pak.BoxLength));
dimensions.Add(new DimensionAmount(pak.BoxWidth));
dimensions.Add(new DimensionAmount(pak.BoxWidth));
}
var sorted = (from d in dimensions
orderby d.Amount descending
select d.Amount).ToList();
dLength = sorted[0];
dwidth = sorted[1];
dHeight = sorted[2];
dGirth = dwidth + dwidth + dHeight + dHeight;
//Dimensions can be skipped in latest UPS specs
if (!ignoreDimensions)
{
if (dLength > 0 | dHeight > 0 | dwidth > 0)
{
DimensionsType commondityDimensions = new DimensionsType();
commondityDimensions.Height = Math.Round(dHeight, 2).ToString(CultureInfo.InvariantCulture);
commondityDimensions.Width = Math.Round(dwidth, 2).ToString(CultureInfo.InvariantCulture);
commondityDimensions.Length = Math.Round(dLength, 2).ToString(CultureInfo.InvariantCulture);
UnitOfMeasurementType unitOfMeasurementDimention = new UnitOfMeasurementType();
unitOfMeasurementDimention.Code = "IN";
unitOfMeasurementDimention.Description = "Inch";
commondityDimensions.UnitOfMeasurement = unitOfMeasurementDimention;
commodity.Dimensions = commondityDimensions;
}
}
return(commodity);
}
public string EP(ProcedureType Procedure_Type, GenderType Gender, double Weight, WeightType Weight_Units,
double Height,
HeightType Height_Units, double Total_Blood_Volume, BloodVolumeType Total_Blood_Volume_Override, double FCR,
double Initial_Hct,
double Target_End_Hct, double Avg_RF_Hct, double Replacement_Volume,
ReplacementVolumeType Replacement_Volume_Override,
double Target_Depletion_Hct, double Blood_Warmer_Volume, int Flag)
{
string Predicted_Error = "None";
double IP_WB_Volume = 0;
double IP_Replaced_Volume = 0;
double PD_Replaced_Volume = 0;
double Total_Waste_Processed = 0;
double RF_Volume = 0;
double FCR_Factor = 1.085;
double RBC_Citrate_Concentration = 21.4;
double Percent_AC_in_RBC = 2;
if (Height_Units == HeightType.inc)
{
Height = Height / 0.3937008 / 100;
}
else
{
Height = Height / 100;
}
if (Weight_Units == WeightType.lbs)
{
Weight = Weight / 2.2046223;
}
Initial_Hct = Initial_Hct / 100;
Avg_RF_Hct = Avg_RF_Hct / 100;
double Blood_Prime_Hct = 0;
double Estimation_Hct = 0; // Estimation_Hct Estimation_Hct = Estimation_Hct / 100;
Target_Depletion_Hct = Target_Depletion_Hct / 100;
Target_End_Hct = Target_End_Hct / 100;
FCR = FCR / 100;
if (Total_Blood_Volume_Override == BloodVolumeType.Nadler)
{
// double Estimation_Hct;
double Low_TBV_Factor = 80;
if (Weight < 25)
{
Total_Blood_Volume = Weight * Low_TBV_Factor;
}
else
{
if (Gender == GenderType.Female)
{
Total_Blood_Volume = (0.3561 * Math.Pow(Height, 3) + 0.03308 * Weight + 0.1833) * 1000;
}
else
{
Total_Blood_Volume = (0.3669 * Math.Pow(Height, 3) + 0.03219 * Weight + 0.6041) * 1000;
}
}
}
double Fluid_Balance = 0;
double Total_Reinfusion_Volume = 0;
double IP_Return_Path_Volume = 60 - 15 + Blood_Warmer_Volume;
double PD_Return_Path_Volume = 60 + Blood_Warmer_Volume;
double Calculated_CIR_Limit = 1.25 * Weight;
double Cit_Con_AC = 21.4;
double Entered_Patient_Volume = Total_Blood_Volume;
double Entered_Patient_Hct = Initial_Hct;
double Entered_Avg_RF_Hct = Avg_RF_Hct;
double Entered_Fluid_Balance = Fluid_Balance;
double Entered_Max_WB_Rate = 50;
double Entered_AC_Ratio = 12;
double Entered_CIR = 1.25;
string Entered_AC_Type = "ACD";
string Entered_Blood_Prime = "None";
double Entered_End_Hct = Target_End_Hct;
string Entered_Divert_Prime = "Yes";
string Entered_Reinfusion = "No";
double Entered_FCR = Math.Exp(Math.Log(FCR) / FCR_Factor) * (Entered_End_Hct / Entered_Patient_Hct) *
((Entered_Patient_Volume + Entered_Fluid_Balance - Total_Reinfusion_Volume) /
Entered_Patient_Volume);
double Entered_Depletion_Hct = 0;
if (Procedure_Type == ProcedureType.Depletion)
{
Entered_Depletion_Hct = Entered_End_Hct;
}
else
{
Entered_Depletion_Hct = Target_Depletion_Hct;
}
double Entered_Replacement_Volume = 0;
if (Replacement_Volume_Override == ReplacementVolumeType.Override)
{
Entered_Replacement_Volume = Replacement_Volume;
}
Predicted_Error = "None";
double Predicted_Replacement_Volume = 0;
double Predicted_Other_RF_Volume = 0;
double RF_AC_Fraction = Percent_AC_in_RBC / 100;
double Cit_Con_Rep_Fluid = RF_AC_Fraction * RBC_Citrate_Concentration;
double CIR_Limited_Qrf = Calculated_CIR_Limit / Cit_Con_Rep_Fluid;
Cit_Con_AC = 21.4;
double EqQb = Calculated_CIR_Limit * (Entered_AC_Ratio + 1) / Cit_Con_AC;
string Divert_Prime = Entered_Divert_Prime;
double Max_WB_Rate = Entered_Max_WB_Rate;
double AC_Ratio = Entered_AC_Ratio;
double Estimation_Volume = Entered_Patient_Volume;
Estimation_Hct = Entered_Patient_Hct;
double Estimation_FCR = 1;
double RF_Used = 0;
Avg_RF_Hct = Entered_Avg_RF_Hct;
Target_End_Hct = Entered_End_Hct;
double Target_FCR = Entered_FCR;
double Target_Volume = Entered_Patient_Volume + Entered_Fluid_Balance - Total_Reinfusion_Volume;
if (Target_Volume < 0.9 * Entered_Patient_Volume)
{
Predicted_Error = "Increase Target Fluid Blance";
}
Target_Depletion_Hct = Entered_Depletion_Hct;
double Target_Replacement_Volume = Entered_Replacement_Volume;
double CIR_Limit = Calculated_CIR_Limit;
double Qwb_Dep = 0;
double Qwb_Ex = 0;
if (Procedure_Type == ProcedureType.Exchange)
{
double Qrf_IP = 0;
double Qwb_IP = Min(CIR_Limited_Qrf * (AC_Ratio + 1) / AC_Ratio, Max_WB_Rate);
Qwb_IP = Min(Qwb_IP, 50);
double Qac_IP = Qwb_IP / (AC_Ratio + 1);
if (Qac_IP < 1.3)
{
Predicted_Error = "AC Ratio Unachievable";
}
if (Estimation_Hct > Avg_RF_Hct)
{
Qrf_IP = Qwb_IP - Qac_IP;
}
else
{
Qrf_IP = (Estimation_Hct / Avg_RF_Hct) * (Qwb_IP - Qac_IP);
}
double Qp_IP = Qwb_IP - Qac_IP - Qrf_IP;
double Remaining_IP_WB_Volume = 105 - IP_WB_Volume;
double Est_Mode_Time = Remaining_IP_WB_Volume / Qwb_IP;
double Total_Return_Volume = (Qrf_IP + Qp_IP) * Est_Mode_Time;
double Mode_RF_Volume = Qrf_IP * Est_Mode_Time;
double Mode_Other_RF_Volume = 0;
double[] Estimation;
if (IP_Replaced_Volume < IP_Return_Path_Volume)
{
IP_Return_Path_Volume = IP_Return_Path_Volume - IP_Replaced_Volume;
if (IP_Return_Path_Volume > Total_Return_Volume)
{
IP_Return_Path_Volume = Total_Return_Volume;
}
double Partial_Time = IP_Return_Path_Volume / (Qwb_IP - Qac_IP);
Estimation = RBCXTT(Qwb_IP - Qac_IP, Qrf_IP, Qp_IP, 0, Partial_Time, Estimation_Volume,
Estimation_Hct, Estimation_FCR);
Estimation_Volume = Estimation[0];
Estimation_Hct = Estimation[1];
Estimation_FCR = Estimation[2];
}
else
{
IP_Return_Path_Volume = 0;
}
// TODO: it line can be wrong
// oroginal kine is If Return_Path_Volume < Total_Return_Volume Then
// but there is not any
if (IP_Return_Path_Volume < Total_Return_Volume)
{
double Partial_Time = (Total_Return_Volume - IP_Return_Path_Volume) / (Qwb_IP - Qac_IP);
Estimation = RBCXTT(Qwb_IP - Qac_IP, Qrf_IP, Qp_IP, Avg_RF_Hct, Partial_Time, Estimation_Volume,
Estimation_Hct, Estimation_FCR);
Estimation_Volume = Estimation[0];
Estimation_Hct = Estimation[1];
Estimation_FCR = Estimation[2];
}
Predicted_Replacement_Volume = Mode_RF_Volume;
Predicted_Other_RF_Volume = Mode_Other_RF_Volume;
Qwb_Ex = Max_WB_Rate;
double Qac_Ex = Qwb_Ex / (AC_Ratio + 1);
if (Qac_Ex < 1.3)
{
Predicted_Error = "AC Ratio Unachievable";
}
if (Replacement_Volume_Override == ReplacementVolumeType.Override)
{
if (Target_Replacement_Volume - RF_Used - Predicted_Replacement_Volume <= 0)
{
Predicted_Error = "Increase Replacement Volume";
}
var Calculated_FCR = CalculatedFCRVR(Estimation_Hct, Avg_RF_Hct, Target_End_Hct,
Target_Volume - Estimation_Volume, Estimation_Volume,
Target_Replacement_Volume - RF_Used - Predicted_Replacement_Volume, (Qwb_Ex - Qac_Ex), 1);
Target_FCR = Calculated_FCR * Estimation_FCR;
if (Target_FCR <= 0)
{
Predicted_Error = "Decrease Replacement Volume";
}
if (Target_FCR >= Estimation_FCR)
{
Predicted_Error = "Decrease Target End Hct";
}
}
else
{
if (Target_FCR <= 0)
{
Predicted_Error = "Increase Target FCR";
}
if (Target_FCR >= Estimation_FCR)
{
Predicted_Error = "Decrease Target FCR";
}
}
if ((Target_FCR / Estimation_FCR) >= (0.99 + ((Target_Volume - Estimation_Volume) / Estimation_Volume)))
{
Predicted_Error = "Increase Target Fluid Balance";
}
double Qrf_Ex = CalculatedFCR((Qwb_Ex - Qac_Ex), Estimation_Volume, (Target_Volume - Estimation_Volume),
Estimation_Hct, Estimation_FCR, Target_End_Hct, Target_FCR, Avg_RF_Hct, 1);
double Qp_Ex = CalculatedFCR((Qwb_Ex - Qac_Ex), Estimation_Volume, (Target_Volume - Estimation_Volume),
Estimation_Hct, Estimation_FCR, Target_End_Hct, Target_FCR, Avg_RF_Hct, 2);
Est_Mode_Time = CalculatedFCR((Qwb_Ex - Qac_Ex), Estimation_Volume, (Target_Volume - Estimation_Volume),
Estimation_Hct, Estimation_FCR, Target_End_Hct, Target_FCR, Avg_RF_Hct, 3);
double Max_Hct = Max(Estimation_Hct, Target_End_Hct);
double Plasma_AC_Fraction = 1 / (((1 - Max_Hct) * AC_Ratio) + 1);
double Estimated_CIR = (Qrf_Ex * Cit_Con_Rep_Fluid) + (Qp_Ex * Cit_Con_AC * Plasma_AC_Fraction);
if (Estimated_CIR > CIR_Limit)
{
double CIR_Adjustment = CIR_Limit / Estimated_CIR;
Qwb_Ex = Qwb_Ex * CIR_Adjustment;
Qac_Ex = Qac_Ex * CIR_Adjustment;
if (Qac_Ex < 1.3)
{
Predicted_Error = "AC Ratio Unachievable";
}
Qrf_Ex = CalculatedFCR((Qwb_Ex - Qac_Ex), Estimation_Volume, (Target_Volume - Estimation_Volume),
Estimation_Hct, Estimation_FCR, Target_End_Hct, Target_FCR, Avg_RF_Hct, 1);
Qp_Ex = CalculatedFCR((Qwb_Ex - Qac_Ex), Estimation_Volume, (Target_Volume - Estimation_Volume),
Estimation_Hct, Estimation_FCR, Target_End_Hct, Target_FCR, Avg_RF_Hct, 2);
Est_Mode_Time = CalculatedFCR((Qwb_Ex - Qac_Ex), Estimation_Volume,
(Target_Volume - Estimation_Volume), Estimation_Hct, Estimation_FCR, Target_End_Hct, Target_FCR,
Avg_RF_Hct, 3);
}
double prbc_Hct = 0.8;
double AC_Dilution = AC_Ratio / (AC_Ratio + 1);
Max_Hct = Max(Estimation_Hct, Target_End_Hct);
double Hct_ACWB = AC_Dilution * Max_Hct;
double Qp_max = Qwb_Ex * (1 - (Hct_ACWB / prbc_Hct));
if (Qp_Ex > Qp_max)
{
Predicted_Error = "Unable to meet Hct";
}
if (Qp_Ex < 1.3)
{
if (Qp_Ex <0 | Qp_Ex> 1E-07)
{
Predicted_Error = "Decrease Target End Hct";
}
else
{
Qp_Ex = 0;
}
}
if (Qrf_Ex > 150)
{
Predicted_Error = "Decrease Target Fluid Balance";
}
if (Qrf_Ex < 1.3)
{
Predicted_Error = "Decrease Target FCR";
}
Mode_RF_Volume = Qrf_Ex * Est_Mode_Time;
Mode_Other_RF_Volume = 0;
if (Estimation_Hct > Target_End_Hct)
{
double Plasma_AC_Fraction_Start = 1 / (((1 - Estimation_Hct) * AC_Ratio) + 1);
double Plasma_AC_Fraction_End = 1 / (((1 - Target_End_Hct) * AC_Ratio) + 1);
Plasma_AC_Fraction = (Plasma_AC_Fraction_Start + Plasma_AC_Fraction_End) / 2;
}
else
{
Plasma_AC_Fraction = 1 / (((1 - Target_End_Hct) * AC_Ratio) + 1);
}
// double Mode_Time = Est_Mode_Time;
Estimation = RBCXTT(Qwb_Ex - Qac_Ex, Qrf_Ex, Qp_Ex, Avg_RF_Hct, Est_Mode_Time, Estimation_Volume,
Estimation_Hct, Estimation_FCR);
double Current_Patient_Volume = Estimation[0];
double Current_Patient_Hct = Estimation[1];
double Current_FCR = Estimation[2];
Estimation_Volume = Current_Patient_Volume;
Estimation_Hct = Current_Patient_Hct;
Estimation_FCR = Current_FCR;
Predicted_Replacement_Volume = Predicted_Replacement_Volume + Mode_RF_Volume;
Predicted_Other_RF_Volume = Predicted_Other_RF_Volume + Mode_Other_RF_Volume;
}
else
{
double Qwb_IP = Min(Max_WB_Rate, 50);
double Qac_IP = Qwb_IP / (AC_Ratio + 1);
if (Qac_IP < 1.3)
{
Predicted_Error = "AC Ratio Unachievable";
}
double Qrf_IP_Est = Qwb_IP - Qac_IP;
double Remaining_IP_WB_Volume = 105 - IP_WB_Volume;
double Est_Mode_Time = Remaining_IP_WB_Volume / Qwb_IP;
double Mode_RF_Volume = 0;
double Mode_Other_RF_Volume = (Qwb_IP - Qac_IP) * Est_Mode_Time;
double[] Estimation = RBCXTT(Qwb_IP - Qac_IP, Qwb_IP - Qac_IP, 0, 0, Est_Mode_Time, Estimation_Volume,
Estimation_Hct, Estimation_FCR);
double Current_Patient_Volume = Estimation[0];
double Current_Patient_Hct = Estimation[1];
double Current_FCR = Estimation[2];
Estimation_Volume = Current_Patient_Volume;
Estimation_Hct = Current_Patient_Hct;
Estimation_FCR = Current_FCR;
Predicted_Replacement_Volume = Mode_RF_Volume;
Predicted_Other_RF_Volume = Mode_Other_RF_Volume;
double Start_Depletion_Hct = Estimation_Hct;
double Volume_to_Remove = -Estimation_Volume *Math.Log(Target_Depletion_Hct / Estimation_Hct);
Qwb_Dep = Min(Max_WB_Rate, EqQb);
double Qac_Dep = Qwb_Dep / (AC_Ratio + 1);
if (Qac_Dep < 1.3)
{
Predicted_Error = "AC Ratio Unachievable";
}
double prbc_Hct = 0.8;
double AC_Dilution = AC_Ratio / (AC_Ratio + 1);
double Avg_Depletion_Hct = (Estimation_Hct + Target_Depletion_Hct) / 2;
double Avg_Hct_ACWB = AC_Dilution * Avg_Depletion_Hct;
double Qp_Ideal_Est = Qwb_Dep * (1 - (Avg_Hct_ACWB / prbc_Hct));
double Qrf_Dep_Est = Qwb_Dep - Qac_Dep - Qp_Ideal_Est;
if (Procedure_Type == ProcedureType.DepletionExchange)
{
Volume_to_Remove = Volume_to_Remove - PD_Return_Path_Volume;
}
if (Volume_to_Remove < 0)
{
Predicted_Error = "Depletion Target Unachievable";
}
Est_Mode_Time = Volume_to_Remove / (Qwb_Dep - Qac_Dep);
double Est_Depletion_Time = Est_Mode_Time;
Mode_RF_Volume = 0;
Mode_Other_RF_Volume = Qrf_Dep_Est * Est_Mode_Time;
Estimation = RBCXTT(Qwb_Dep - Qac_Dep, Qwb_Dep - Qac_Dep, 0, 0, Est_Mode_Time, Estimation_Volume,
Estimation_Hct, Estimation_FCR);
Current_Patient_Volume = Estimation[0];
Current_Patient_Hct = Estimation[1];
Current_FCR = Estimation[2];
Estimation_Volume = Current_Patient_Volume;
Estimation_Hct = Current_Patient_Hct;
Estimation_FCR = Current_FCR;
Predicted_Replacement_Volume = Predicted_Replacement_Volume + Mode_RF_Volume;
Predicted_Other_RF_Volume = Predicted_Other_RF_Volume + Mode_Other_RF_Volume;
double Plasma_AC_Fraction_Start = 1 / (((1 - Start_Depletion_Hct) * AC_Ratio) + 1);
double Plasma_AC_Fraction_End = 1 / (((1 - Estimation_Hct) * AC_Ratio) + 1);
double Plasma_AC_Fraction = (Plasma_AC_Fraction_Start + Plasma_AC_Fraction_End) / 2;
if (Procedure_Type == ProcedureType.DepletionExchange)
{
double Qwb_PD = Max_WB_Rate;
double Qac_PD = Qwb_PD / (AC_Ratio + 1);
if (Qac_PD < 1.3)
{
Predicted_Error = "AC Ratio Unachievable";
}
double PD_FCR;
if (Replacement_Volume_Override == ReplacementVolumeType.Override)
{
if (Target_Replacement_Volume - RF_Used - Predicted_Replacement_Volume <= 0)
{
Predicted_Error = "Increase_Replacement_Volume";
}
double Calculated_FCR = CalculatedFCRVR(Estimation_Hct, Avg_RF_Hct, Target_End_Hct,
Target_Volume - Estimation_Volume, Estimation_Volume,
Target_Replacement_Volume - RF_Used - Predicted_Replacement_Volume, Qwb_PD - Qac_PD, 1);
PD_FCR = Calculated_FCR * Estimation_FCR;
if (PD_FCR <= 0)
{
Predicted_Error = "Decrease Replacement Volume";
}
if (PD_FCR >= Estimation_FCR)
{
Predicted_Error = "Decrease Target End Hct";
}
}
else
{
PD_FCR = Target_FCR;
if (PD_FCR <= 0)
{
Predicted_Error = "Increase Target FCR";
}
if (PD_FCR >= Estimation_FCR)
{
Predicted_Error = "Decrease Target FCR";
}
}
if ((PD_FCR / Estimation_FCR) >= (0.99 + ((Target_Volume - Estimation_Volume) / Estimation_Volume)))
{
Predicted_Error = "Increase_Target_Fluid_Balance";
}
double Qrf_PD = CalculatedFCR(Qwb_PD - Qac_PD, Estimation_Volume, Target_Volume - Estimation_Volume,
Estimation_Hct, Estimation_FCR, Target_End_Hct, PD_FCR, Avg_RF_Hct, 1);
double Qp_PD = CalculatedFCR(Qwb_PD - Qac_PD, Estimation_Volume, Target_Volume - Estimation_Volume,
Estimation_Hct, Estimation_FCR, Target_End_Hct, PD_FCR, Avg_RF_Hct, 2);
double Max_Hct = Max(Estimation_Hct, Target_End_Hct);
Plasma_AC_Fraction = 1 / (((1 - Max_Hct) * AC_Ratio) + 1);
double Estimated_CIR = (Qrf_PD * Cit_Con_Rep_Fluid) + (Qp_PD * Cit_Con_AC * Plasma_AC_Fraction);
if (Estimated_CIR > CIR_Limit)
{
double CIR_Adjustment = CIR_Limit / Estimated_CIR;
Qwb_PD = Qwb_PD * CIR_Adjustment;
Qac_PD = Qac_PD * CIR_Adjustment;
if (Qac_PD < 1.3)
{
Predicted_Error = "AC Ratio Unachievable";
}
Qrf_PD = CalculatedFCR(Qwb_PD - Qac_PD, Estimation_Volume, Target_Volume - Estimation_Volume,
Estimation_Hct, Estimation_FCR, Target_End_Hct, PD_FCR, Avg_RF_Hct, 1);
Qp_PD = CalculatedFCR(Qwb_PD - Qac_PD, Estimation_Volume, Target_Volume - Estimation_Volume,
Estimation_Hct, Estimation_FCR, Target_End_Hct, PD_FCR, Avg_RF_Hct, 2);
}
prbc_Hct = 0.8;
AC_Dilution = AC_Ratio / (AC_Ratio + 1);
Max_Hct = Max(Estimation_Hct, Target_End_Hct);
double Hct_ACWB = AC_Dilution * Max_Hct;
double Qp_max = Qwb_PD * (1 - (Hct_ACWB / prbc_Hct));
if (Qp_PD > Qp_max)
{
Predicted_Error = "Increase Target End Hct";
}
if (Qp_PD < 1.3)
{
if (Qp_PD <0 | Qp_PD> 1E-07)
{
Predicted_Error = "Decrease Target End Hct";
}
else
{
Qp_PD = 0;
}
}
if (Qrf_PD > 150)
{
Predicted_Error = "Decrease Target Fluid Balance";
}
if (Qrf_PD < 1.3)
{
Predicted_Error = "Decrease Target FCR";
}
double PD_Volume_Remaining = PD_Return_Path_Volume - PD_Replaced_Volume;
Est_Mode_Time = PD_Volume_Remaining / (Qrf_PD + Qp_PD);
Mode_RF_Volume = Qrf_PD * Est_Mode_Time;
Mode_Other_RF_Volume = 0;
if (Estimation_Hct > Target_Depletion_Hct)
{
Plasma_AC_Fraction_Start = 1 / (((1 - Estimation_Hct) * AC_Ratio) + 1);
Plasma_AC_Fraction_End = 1 / (((1 - Target_Depletion_Hct) * AC_Ratio) + 1);
Plasma_AC_Fraction = (Plasma_AC_Fraction_Start + Plasma_AC_Fraction_End) / 2;
}
else
{
Plasma_AC_Fraction = 1 / (((1 - Target_End_Hct) * AC_Ratio) + 1);
}
Estimation = RBCXTT(Qwb_PD - Qac_PD, Qrf_PD, Qp_PD, 0, Est_Mode_Time, Estimation_Volume,
Estimation_Hct, Estimation_FCR);
Current_Patient_Volume = Estimation[0];
Current_Patient_Hct = Estimation[1];
Current_FCR = Estimation[2];
Estimation_Volume = Current_Patient_Volume;
Estimation_Hct = Current_Patient_Hct;
Estimation_FCR = Current_FCR;
Predicted_Replacement_Volume = Predicted_Replacement_Volume + Mode_RF_Volume;
Predicted_Other_RF_Volume = Predicted_Other_RF_Volume + Mode_Other_RF_Volume;
Qwb_Ex = Max_WB_Rate;
double Qac_Ex = Qwb_Ex / (AC_Ratio + 1);
if (Qac_Ex < 1.3)
{
Predicted_Error = "AC Ratio Unachievable";
}
if (Replacement_Volume_Override == ReplacementVolumeType.Override)
{
if (Target_Replacement_Volume - RF_Used - Predicted_Replacement_Volume <= 0)
{
Predicted_Error = "Increase Replacement Volume";
}
double Calculated_FCR = CalculatedFCRVR(Estimation_Hct, Avg_RF_Hct, Target_End_Hct,
Target_Volume - Estimation_Volume, Estimation_Volume,
Target_Replacement_Volume - RF_Used - Predicted_Replacement_Volume, (Qwb_Ex - Qac_Ex), 1);
Target_FCR = Calculated_FCR * Estimation_FCR;
if (Target_FCR < 0)
{
Predicted_Error = "Decrease Replacement Volume";
}
if (Target_FCR >= Estimation_FCR)
{
Predicted_Error = "Decrease Target End Hct";
}
}
else
{
if (Target_FCR <= 0)
{
Predicted_Error = "Increase_Target_FCR";
}
if (Target_FCR >= Estimation_FCR)
{
Predicted_Error = "Decrease Target FCR";
}
}
if ((Target_FCR / Estimation_FCR) >= (0.99 + ((Target_Volume - Estimation_Volume) / Estimation_Volume)))
{
Predicted_Error = "Increase Target Fluid Balance";
}
double Qrf_Ex = CalculatedFCR((Qwb_Ex - Qac_Ex), Estimation_Volume,
(Target_Volume - Estimation_Volume), Estimation_Hct, Estimation_FCR, Target_End_Hct, Target_FCR,
Avg_RF_Hct, 1);
double Qp_Ex = CalculatedFCR((Qwb_Ex - Qac_Ex), Estimation_Volume,
(Target_Volume - Estimation_Volume), Estimation_Hct, Estimation_FCR, Target_End_Hct, Target_FCR,
Avg_RF_Hct, 2);
Est_Mode_Time = CalculatedFCR((Qwb_Ex - Qac_Ex), Estimation_Volume,
(Target_Volume - Estimation_Volume), Estimation_Hct, Estimation_FCR, Target_End_Hct, Target_FCR,
Avg_RF_Hct, 3);
Max_Hct = Max(Estimation_Hct, Target_End_Hct);
Plasma_AC_Fraction = 1 / (((1 - Max_Hct) * AC_Ratio) + 1);
Estimated_CIR = (Qrf_Ex * Cit_Con_Rep_Fluid) + (Qp_Ex * Cit_Con_AC * Plasma_AC_Fraction);
if (Estimated_CIR > CIR_Limit)
{
double CIR_Adjustment = CIR_Limit / Estimated_CIR;
Qwb_Ex = Qwb_Ex * CIR_Adjustment;
Qac_Ex = Qac_Ex * CIR_Adjustment;
if (Qac_Ex < 1.3)
{
Predicted_Error = "AC Ratio Unachievable";
}
Qrf_Ex = CalculatedFCR((Qwb_Ex - Qac_Ex), Estimation_Volume, (Target_Volume - Estimation_Volume),
Estimation_Hct, Estimation_FCR, Target_End_Hct, Target_FCR, Avg_RF_Hct, 1);
Qp_Ex = CalculatedFCR((Qwb_Ex - Qac_Ex), Estimation_Volume, (Target_Volume - Estimation_Volume),
Estimation_Hct, Estimation_FCR, Target_End_Hct, Target_FCR, Avg_RF_Hct, 2);
Est_Mode_Time = CalculatedFCR((Qwb_Ex - Qac_Ex), Estimation_Volume,
(Target_Volume - Estimation_Volume), Estimation_Hct, Estimation_FCR, Target_End_Hct,
Target_FCR, Avg_RF_Hct, 3);
}
prbc_Hct = 0.8;
AC_Dilution = AC_Ratio / (AC_Ratio + 1);
Max_Hct = Max(Estimation_Hct, Target_End_Hct);
Hct_ACWB = AC_Dilution * Max_Hct;
Qp_max = Qwb_Ex * (1 - (Hct_ACWB / prbc_Hct));
if (Qp_Ex > Qp_max)
{
Predicted_Error = "Unable to meet Hct";
}
if (Qp_Ex < 1.3)
{
if (Qp_Ex <0 | Qp_Ex> 1E-07)
{
Predicted_Error = "Decrease Target End Hct";
}
else
{
Qp_Ex = 0;
}
}
if (Qrf_Ex > 150)
{
Predicted_Error = "Decrease Target Fluid Balance";
}
if (Qrf_Ex < 1.3)
{
Predicted_Error = "Decrease Target FCR";
}
Mode_RF_Volume = Qrf_Ex * Est_Mode_Time;
Mode_Other_RF_Volume = 0;
if (Estimation_Hct > Target_End_Hct)
{
Plasma_AC_Fraction_Start = 1 / (((1 - Estimation_Hct) * AC_Ratio) + 1);
Plasma_AC_Fraction_End = 1 / (((1 - Target_End_Hct) * AC_Ratio) + 1);
Plasma_AC_Fraction = (Plasma_AC_Fraction_Start + Plasma_AC_Fraction_End) / 2;
}
else
{
Plasma_AC_Fraction = 1 / (((1 - Target_End_Hct) * AC_Ratio) + 1);
}
//double Mode_Time = Est_Mode_Time;
Estimation = RBCXTT(Qwb_Ex - Qac_Ex, Qrf_Ex, Qp_Ex, Avg_RF_Hct, Est_Mode_Time, Estimation_Volume,
Estimation_Hct, Estimation_FCR);
Current_Patient_Volume = Estimation[0];
Current_Patient_Hct = Estimation[1];
Current_FCR = Estimation[2];
Estimation_Volume = Current_Patient_Volume;
Estimation_Hct = Current_Patient_Hct;
Estimation_FCR = Current_FCR;
Predicted_Replacement_Volume = Predicted_Replacement_Volume + Mode_RF_Volume;
Predicted_Other_RF_Volume = Predicted_Other_RF_Volume + Mode_Other_RF_Volume;
}
}
double Est_Other_RF = Predicted_Other_RF_Volume;
double WB_Flow_Rate;
if (Predicted_Error == "None")
{
if (Procedure_Type == ProcedureType.Depletion)
{
WB_Flow_Rate = Qwb_Dep;
}
else
{
WB_Flow_Rate = Qwb_Ex;
}
if (Replacement_Volume_Override == ReplacementVolumeType.Override)
{
FCR = Estimation_FCR;
}
else
{
Replacement_Volume = Predicted_Replacement_Volume;
}
}
else
{
if (Replacement_Volume_Override == ReplacementVolumeType.Override)
{
FCR = 0;
}
else
{
Replacement_Volume = 0;
}
Est_Other_RF = 0;
}
if (Flag == 0)
{
var r =
(Math.Pow(
(Estimation_FCR * (Entered_Patient_Volume / Estimation_Volume) * (Entered_Patient_Hct / Estimation_Hct)),
(FCR_Factor))) * 100;
return(r.ToString());
}
if (Flag == 1)
{
return(Replacement_Volume.ToString());
}
if (Flag == 2)
{
Est_Other_RF.ToString();
}
if (Flag == 3)
{
return(Predicted_Error);
}
return(null);
}
/// <summary>
/// Assigns measurement and measurement type.
/// </summary>
/// <param name="measurement"></param>
/// <param name="measurementType"></param>
internal void AssignMeasurement(double? measurement, WeightType measurementType)
{
if (measurement.HasValue)
{
//A non null value is being assigned for this type
_measurement = measurement;
_measurementType = measurementType;
}
else if ((measurement.HasValue == false) && (_measurementType == measurementType))
{
//The measurements are being cleared.
_measurement = null;
_measurementType = null;
}
}
public Weight(decimal?value, WeightType weightType)
{
Value = value;
WeightType = weightType;
}
private static double correct(bool unbiased, WeightType weightType, double sum, double weightSum, double squareSum)
{
if (unbiased)
{
if (weightType == WeightType.Automatic)
{
if (weightSum > 1 && weightSum.IsInteger(1e-8))
return sum / (weightSum - 1);
return sum / (weightSum - (squareSum / weightSum));
}
else if (weightType == WeightType.Fraction)
{
/*
if (Math.Abs(weightSum - 1.0) >= 1e-8)
{
throw new ArgumentException("An unbiased variance estimate"
+ " cannot be computed if weights do not sum to one. The"
+ " given weights sum up to " + squareSum, "weights");
}*/
return sum / (weightSum - (squareSum / weightSum));
}
else if (weightType == WeightType.Repetition)
{
return sum / (weightSum - (squareSum / weightSum));
}
}
return sum / weightSum;
}
static void Main()
{
try
{
FreightShipService freightShipService = new FreightShipService();
FreightShipRequest freightShipRequest = new FreightShipRequest();
RequestType request = new RequestType();
String[] requestOption = { "1" };
request.RequestOption = requestOption;
freightShipRequest.Request = request;
ShipmentType shipment = new ShipmentType();
/** ****************ShipFrom******************************* */
ShipFromType shipFrom = new ShipFromType();
FreightShipAddressType shipFromAddress = new FreightShipAddressType();
String[] shipFromAddressLines = { "ShipFrom address line" };
shipFromAddress.AddressLine = shipFromAddressLines;
shipFromAddress.City = "Roswell";
shipFromAddress.StateProvinceCode = "GA";
shipFromAddress.PostalCode = "30076";
shipFromAddress.CountryCode = "US";
shipFrom.Address = shipFromAddress;
shipFrom.AttentionName = "XYZ Associates";
shipFrom.Name = "XYZ Associates";
FreightShipPhoneType shipFromPhone = new FreightShipPhoneType();
shipFromPhone.Number = "123456789";
shipFromPhone.Extension = "34567";
shipFrom.Phone = shipFromPhone;
shipFrom.EMailAddress = "*****@*****.**";
shipment.ShipFrom = shipFrom;
/** ****************ShipFrom******************************* */
shipment.ShipperNumber = "Your shipper number";
/** ****************ShipTo*************************************** */
ShipToType shipTo = new ShipToType();
FreightShipAddressType shipToAddress = new FreightShipAddressType();
String[] shipToAddressLines = { "ShipTo address line" };
shipToAddress.AddressLine = shipToAddressLines;
shipToAddress.City = "Roswell";
shipToAddress.StateProvinceCode = "GA";
shipToAddress.PostalCode = "30076";
shipToAddress.CountryCode = "US";
shipTo.Address = shipFromAddress;
shipTo.AttentionName = "PQR Associates";
shipTo.Name = "PQR";
FreightShipPhoneType shipToPhone = new FreightShipPhoneType();
shipToPhone.Number = "123456789";
shipToPhone.Extension = "34567";
shipTo.Phone = shipToPhone;
shipTo.EMailAddress = "*****@*****.**";
shipment.ShipTo = shipTo;
/** ****************ShipTo*************************************** */
/** ***************PaymentInformationType************************* */
PaymentInformationType paymentInfo = new PaymentInformationType();
PayerType payer = new PayerType();
payer.AttentionName = "Mr. XYZ";
payer.Name = "XYZ Associates";
FreightShipPhoneType payerPhone = new FreightShipPhoneType();
payerPhone.Number = "123456789";
payerPhone.Extension = "3456";
payer.Phone = payerPhone;
payer.ShipperNumber = "Your Shipper Number";
payer.EMailAddress = "*****@*****.**";
FreightShipAddressType payerAddress = new FreightShipAddressType();
String[] payerAddressLines = { "Payer address line" };
payerAddress.AddressLine = payerAddressLines;
payerAddress.City = "Roswell";
payerAddress.StateProvinceCode = "GA";
payerAddress.PostalCode = "30075";
payerAddress.CountryCode = "US";
payer.Address = payerAddress;
paymentInfo.Payer = payer;
ShipCodeDescriptionType shipBillOption = new ShipCodeDescriptionType();
shipBillOption.Code = "10";
shipBillOption.Description = "PREPAID";
paymentInfo.ShipmentBillingOption = shipBillOption;
shipment.PaymentInformation = paymentInfo;
/** ***************PaymentInformationType************************* */
/** ***************Service************************************** */
ShipCodeDescriptionType service = new ShipCodeDescriptionType();
service.Code = "309";
service.Description = "UPS Ground Freight";
shipment.Service = service;
/** ***************Service************************************** */
//Below sample contains dummy data for your reference
//Please update dummy date as per your requirement
/** **************Commodity************************************* */
CommodityType commodity = new CommodityType();
commodity.NumberOfPieces = "20";
NMFCCommodityType nmfcCommodity = new NMFCCommodityType();
nmfcCommodity.PrimeCode = "132680";
nmfcCommodity.SubCode = "02";
commodity.NMFCCommodity = nmfcCommodity;
commodity.FreightClass = "77.5";
ShipCodeDescriptionType packagingType = new ShipCodeDescriptionType();
packagingType.Code = "BAG";
packagingType.Description = "BAG";
commodity.PackagingType = packagingType;
WeightType weight = new WeightType();
weight.Value = "200";
FreightShipUnitOfMeasurementType unitOfMeasurement = new FreightShipUnitOfMeasurementType();
unitOfMeasurement.Code = "lbs";
unitOfMeasurement.Description = "pounds";
weight.UnitOfMeasurement = unitOfMeasurement;
commodity.Weight = weight;
CommodityValueType commodityValue = new CommodityValueType();
commodityValue.CurrencyCode = "USD";
commodityValue.MonetaryValue = "100";
commodity.CommodityValue = commodityValue;
commodity.Description = "LCD TVS";
CommodityType[] commodityArray = { commodity };
shipment.Commodity = commodityArray;
/** **************Commodity************************************* */
/** **************HandlingUnitOne************************** */
HandlingUnitType handlingUnit = new HandlingUnitType();
handlingUnit.Quantity = "1";
ShipCodeDescriptionType handlingUnitType = new ShipCodeDescriptionType();
handlingUnitType.Code = "SKD";
handlingUnitType.Description = "SKID";
handlingUnit.Type = handlingUnitType;
shipment.HandlingUnitOne = handlingUnit;
/** **************HandlingUnitOne************************** */
UPSSecurity upss = new UPSSecurity();
UPSSecurityServiceAccessToken upssSvcAccessToken = new UPSSecurityServiceAccessToken();
upssSvcAccessToken.AccessLicenseNumber = "Your License";
upss.ServiceAccessToken = upssSvcAccessToken;
UPSSecurityUsernameToken upssUsrNameToken = new UPSSecurityUsernameToken();
upssUsrNameToken.Username = "******";
upssUsrNameToken.Password = "******";
upss.UsernameToken = upssUsrNameToken;
freightShipService.UPSSecurityValue = upss;
freightShipRequest.Shipment = shipment;
System.Net.ServicePointManager.CertificatePolicy = new TrustAllCertificatePolicy();
Console.WriteLine(freightShipRequest);
FreightShipResponse freightShipResponse = freightShipService.ProcessShipment(freightShipRequest);
Console.WriteLine("The transaction was a " + freightShipResponse.Response.ResponseStatus.Description);
Console.WriteLine("The BOLID of the shipment is: " + freightShipResponse.ShipmentResults.BOLID);
Console.WriteLine("The Shipment number of the shipment is " + freightShipResponse.ShipmentResults.ShipmentNumber);
Console.ReadKey();
}
catch (System.Web.Services.Protocols.SoapException ex)
{
Console.WriteLine("");
Console.WriteLine("---------FreightShip Web Service returns error----------------");
Console.WriteLine("---------\"Hard\" is user error \"Transient\" is system error----------------");
Console.WriteLine("SoapException Message= " + ex.Message);
Console.WriteLine("");
Console.WriteLine("SoapException Category:Code:Message= " + ex.Detail.LastChild.InnerText);
Console.WriteLine("");
Console.WriteLine("SoapException XML String for all= " + ex.Detail.LastChild.OuterXml);
Console.WriteLine("");
Console.WriteLine("SoapException StackTrace= " + ex.StackTrace);
Console.WriteLine("-------------------------");
Console.WriteLine("");
}
catch (System.ServiceModel.CommunicationException ex)
{
Console.WriteLine("");
Console.WriteLine("--------------------");
Console.WriteLine("CommunicationException= " + ex.Message);
Console.WriteLine("CommunicationException-StackTrace= " + ex.StackTrace);
Console.WriteLine("-------------------------");
Console.WriteLine("");
}
catch (Exception ex)
{
Console.WriteLine("");
Console.WriteLine("-------------------------");
Console.WriteLine(" Generaal Exception= " + ex.Message);
Console.WriteLine(" Generaal Exception-StackTrace= " + ex.StackTrace);
Console.WriteLine("-------------------------");
}
finally
{
Console.ReadKey();
}
}
double GetIncludedWeight(
WeightType prev_state, WeightType next_state,
double prev_weight_percent, double next_weight_percent,
double start_percent, double end_percent,
double cur_weight_percent)
{
if (prev_state == WeightType.UnderStart)
{
if (next_state == WeightType.UnderStart)
{
return 0.0;
}
else if (next_state == WeightType.BetweenStartEnd)
{
return next_weight_percent - start_percent;
}
else
{
return end_percent - start_percent;
}
}
else if (prev_state == WeightType.BetweenStartEnd)
{
if (next_state == WeightType.UnderStart)
{
logger.Warn("Invalid");
return 0.0;
}
else if (next_state == WeightType.BetweenStartEnd)
{
return cur_weight_percent;
}
else
{
return end_percent - prev_weight_percent;
}
}
else if (prev_state == WeightType.OverEnd)
{
return 0;
}
else
{
logger.Warn("Invalid");
}
return 0;
}
//Returns true if the vertex's matrix node is changed.
private bool Weight(float value, Vertex3 vertex, WeightType type)
{
if (_targetBone == null || _targetBone.Locked)
{
return(false);
}
Influence targetInf = null;
BoneWeight targetWeight = null;
float max = 1.0f;
//Get the matrix that influences this vertex
IMatrixNode node = vertex.GetMatrixNode();
bool startsAsBone = false;
//Convert a single bone into an influence so bones can be added to it later
if (node is MDL0BoneNode)
{
startsAsBone = true;
node = new Influence(node as MDL0BoneNode);
}
//Duplicate the influence if it affects more than just this vertex
targetInf = node.Users.Count > 1 ?
(node as Influence).Clone() :
node as Influence;
//Find or add the current bone to the influence
List <BoneWeight> weights = targetInf.Weights;
int selectedIndex = weights.Select(x => x.Bone).ToArray().IndexOf(TargetBone);
if (selectedIndex < 0)
{
weights.Add(new BoneWeight(TargetBone, 0.0f));
selectedIndex = weights.Count - 1;
}
//Get the weight at the index of the current bone
targetWeight = targetInf.Weights[selectedIndex];
//Can't do anything to a locked weight
if (targetWeight.Locked)
{
return(false);
}
//Get the sum of all weights that can be edited by subtracting all locked values from 1.0f
max = 1.0f;
foreach (BoneWeight b in weights)
{
if (b.Locked)
{
max -= b.Weight;
}
}
//Get the new value for the target weight
//Clamp it between 0.0f and the max value
switch (type)
{
default:
value = RoundValue(value, max);
break;
case WeightType.Add:
value = RoundValue(targetWeight.Weight + value, max);
break;
case WeightType.Multiply:
value = RoundValue(targetWeight.Weight * value, max);
break;
}
//Nothing to do if there's no change in value
if (targetWeight.Weight == value)
{
return(false);
}
//Collect all unlocked weights that are not the current weight
//These are weights that will be changed to accomodate the current weight edit
List <int> editableWeights = new List <int>();
for (int i = 0; i < targetInf.Weights.Count; i++)
{
if (!targetInf.Weights[i].Locked && i != selectedIndex)
{
editableWeights.Add(i);
}
}
//Return if nothing can be edited
if (editableWeights.Count == 0)
{
return(false);
}
//Set the current weight with the calculated value
targetWeight.Weight = value;
//Get the change in value, divide it by all other editable weights,
//and then add that value to those weights to bring the overall weight sum back to 1.0f
float perBoneDiff = (targetWeight.Weight - value) / editableWeights.Count;
if (value < max)
{
foreach (int i in editableWeights)
{
targetInf.Weights[i].Weight = RoundValue(targetInf.Weights[i].Weight + perBoneDiff, 1.0f);
}
}
else
{
foreach (int i in editableWeights)
{
targetInf.Weights[i].Weight = 0.0f;
}
}
//Normalize the influence just in case, this will scale all weights so they add up to 1.0f
//Don't let the modified value be normalized, lock it
bool locked = targetWeight.Locked;
targetWeight.Locked = true;
targetInf.Normalize();
targetWeight.Locked = locked;
//Clean influence by removing zero weights
for (int i = 0; i < targetInf.Weights.Count; i++)
{
if (targetInf.Weights[i].Weight <= 0.0f)
{
targetInf.Weights.RemoveAt(i--);
}
}
MDL0ObjectNode obj = vertex.Parent as MDL0ObjectNode;
MDL0Node model = obj.Model;
IMatrixNode matrixNode;
//See if the influence is just one bone
if (targetInf.Weights.Count == 1)
{
matrixNode = targetInf.Weights[0].Bone;
if (!startsAsBone && !_anyConverted.Contains(obj))
{
_anyConverted.Add(obj);
}
}
else
{
matrixNode = model._influences.FindOrCreate(targetInf);
if (startsAsBone && !_anyConverted.Contains(obj))
{
_anyConverted.Add(obj);
}
}
//Move influence to each vertex before modifying the influence of one vertex
if (obj.MatrixNode != null)
{
obj.TryConvertMatrixToVertex();
}
vertex.DeferUpdateAssets();
vertex.MatrixNode = matrixNode;
return(true);
}
