217 lines
8.6 KiB
C#
217 lines
8.6 KiB
C#
using dcnsanplanung.bewertung.M149_3;
|
|
using dcnsanplanung.shared.Model;
|
|
using System.Diagnostics;
|
|
|
|
namespace dcnsanplanung.bewertung
|
|
{
|
|
public static class BewM149
|
|
{
|
|
|
|
public static Dictionary<int, int> StartWert = new Dictionary<int, int>()
|
|
{
|
|
{0,400 },
|
|
{1,300 },
|
|
{2,200 },
|
|
{3,100 },
|
|
{4,0 },
|
|
{5,0 }
|
|
};
|
|
|
|
public static float SXj(int sk,float length)
|
|
{
|
|
return (5 - sk) * length;
|
|
}
|
|
|
|
public static Dictionary<string, int> ObjektKlasse(List<Schaden> schaeden)
|
|
{
|
|
Dictionary<string, int> result = new Dictionary<string, int>();
|
|
|
|
result.Add("B", schaeden.Select(x => x.KB).Min());
|
|
result.Add("D", schaeden.Select(x => x.KD).Min());
|
|
result.Add("S", schaeden.Select(x => x.KS).Min());
|
|
|
|
return result;
|
|
}
|
|
|
|
public static void CalculateHaltung(Haltung haltung)
|
|
{
|
|
var k = ObjektKlasse(haltung.Kodierungen);
|
|
|
|
foreach (var schaden in haltung.Kodierungen)
|
|
{
|
|
schaden.KBj = SXj(schaden.KB, 2.5f);
|
|
schaden.KDj = SXj(schaden.KD, 2.5f);
|
|
schaden.KSj = SXj(schaden.KS, 2.5f);
|
|
}
|
|
|
|
float Haltungslaenge = (float)haltung.Kodierungen.Select(x => x.Entfernung).Max();
|
|
|
|
float KBSumme = haltung.Kodierungen.Select(x => x.KBj).Sum();
|
|
float KSSumme = haltung.Kodierungen.Select(x => x.KSj).Sum();
|
|
float KDSumme = haltung.Kodierungen.Select(x => x.KDj).Sum();
|
|
|
|
float ObjektDSumme = SXj(k["D"],Haltungslaenge);
|
|
float ObjektSSumme = SXj(k["S"],Haltungslaenge);
|
|
float ObjektBSumme = SXj(k["B"],Haltungslaenge);
|
|
|
|
float SchadensDichteD = KDSumme / ObjektDSumme;
|
|
float SchadensDichteS = KSSumme / ObjektSSumme;
|
|
float SchadensDichteB = KBSumme / ObjektBSumme;
|
|
|
|
float zuschlagD = 50 * SchadensDichteD;
|
|
float zuschlagS = 50 * SchadensDichteS;
|
|
float zuschlagB = 50 * SchadensDichteB;
|
|
|
|
int startWertD = StartWert[k["D"]];
|
|
int startWertB = StartWert[k["B"]];
|
|
int startWertS = StartWert[k["S"]];
|
|
|
|
int ZustandPunkteD = startWertD + (int)zuschlagD;
|
|
int ZustandPunkteB = startWertB + (int)zuschlagB;
|
|
int ZustandPunkteS = startWertS + (int)zuschlagS;
|
|
|
|
int BewertungspunkteD = ZustandPunkteD + 500 + RD(EBaujahr.VOR1965, EEinstau.NICHTEINGEHALTEN, ELageGrundWasser.IM);
|
|
int BewertungspunkteS = ZustandPunkteS + 500 + RS(EUeberdeckung.KLEINER25, EBodenGruppe.BG4);
|
|
int BewertungspunkteB = ZustandPunkteB + 500 + RB(EEinstau.NICHTEINGEHALTEN, EUeberdeckung.KLEINER25);
|
|
|
|
// Sanierungsbedarfzahl errechnen
|
|
List<int> ints = new List<int>();
|
|
ints.Add(BewertungspunkteB);
|
|
ints.Add(BewertungspunkteS);
|
|
ints.Add(BewertungspunkteD);
|
|
|
|
int bp1 = ints.Max();
|
|
int bp3 = ints.Min();
|
|
int bp2 = ints.Sum() - bp1 - bp3;
|
|
|
|
int restbp1 = Convert.ToInt32(bp1.ToString().Substring(1));
|
|
int restbp2 = Convert.ToInt32(bp2.ToString().Substring(1));
|
|
int restbp3 = Convert.ToInt32(bp3.ToString().Substring(1));
|
|
|
|
int rest = (restbp1 + restbp2 + restbp3) / 30;
|
|
|
|
string sanierungszahl = string.Format("{0}{1}{2}{3}",(int)(bp1 / 100),(int)(bp2 /100),(int)(bp3 / 100),rest);
|
|
|
|
int sanzahl = Convert.ToInt32(sanierungszahl);
|
|
}
|
|
|
|
public static Tuple<string,string> Beurteilung(int sanierungsbedarfzahl)
|
|
{
|
|
switch(sanierungsbedarfzahl)
|
|
{
|
|
case >= 9000: return new Tuple<string, string>("sofort", "sehr starker Mangel / Gefahr im Verzuge");
|
|
case >= 8000: return new Tuple<string, string>("kurzfristig", "starker Mangel");
|
|
case >= 7000: return new Tuple<string, string>("mittelfristig", "mittlere Mangel");
|
|
case >= 6000: return new Tuple<string, string>("langfristig", "leichter Mangel");
|
|
case >= 5000: return new Tuple<string, string>("keiner (geringfügige Schäden", "geringfügiger Mangel");
|
|
default: return new Tuple<string, string>("schadensfrei", "kein Mangel");
|
|
}
|
|
}
|
|
|
|
public enum EBaujahr
|
|
{
|
|
VOR1965,
|
|
NACH1965
|
|
}
|
|
public enum EEinstau
|
|
{
|
|
EINGEHALTEN,
|
|
NICHTEINGEHALTEN
|
|
}
|
|
public enum ELageGrundWasser
|
|
{
|
|
IM,
|
|
AUSSER,
|
|
WECHSEL
|
|
}
|
|
public enum EUeberdeckung
|
|
{
|
|
KLEINER25,
|
|
ZWISCHEN25UND4,
|
|
GROESSER4
|
|
|
|
}
|
|
public enum EBodenGruppe
|
|
{
|
|
BG1,
|
|
BG2,
|
|
BG3,
|
|
BG4
|
|
}
|
|
public static int RD(EBaujahr eBaujahr, EEinstau eEinstau, ELageGrundWasser eLageGrundWasser)
|
|
{
|
|
int ver1 = eBaujahr == EBaujahr.VOR1965 ? 1 : 0;
|
|
int ver2 = eEinstau == EEinstau.EINGEHALTEN ? 0 : 1;
|
|
decimal ver3 = eLageGrundWasser == ELageGrundWasser.IM ? 1 : eLageGrundWasser == ELageGrundWasser.WECHSEL ? 0.5m : 0;
|
|
decimal summe = ((ver1+ver2+ver3) / 3) * 50;
|
|
return (int)Math.Ceiling(summe);
|
|
}
|
|
public static int RB(EEinstau eEinstau, EUeberdeckung eUeberdeckung)
|
|
{
|
|
int ver1 = eEinstau == EEinstau.EINGEHALTEN ? 0 : 1;
|
|
decimal ver2 = eUeberdeckung == EUeberdeckung.KLEINER25 ? 1 : eUeberdeckung == EUeberdeckung.ZWISCHEN25UND4 ? 0.5m : 0;
|
|
decimal summe = ((ver1+ ver2) / 2)*50;
|
|
return (int)Math.Ceiling(summe);
|
|
}
|
|
|
|
|
|
public static int RS(EUeberdeckung eUeberdeckung, EBodenGruppe eBodenGruppe)
|
|
{
|
|
decimal ver1 = eUeberdeckung == EUeberdeckung.KLEINER25 ? 1 : eUeberdeckung == EUeberdeckung.ZWISCHEN25UND4 ? 0.5m : 0;
|
|
decimal ver2 = eBodenGruppe == EBodenGruppe.BG1 ? 0 : eBodenGruppe == EBodenGruppe.BG2 ? 0 : eBodenGruppe == EBodenGruppe.BG3 ? 0.5m : 1;
|
|
decimal summe = ((ver1 + ver2) / 2) * 50;
|
|
return (int)Math.Ceiling(summe);
|
|
}
|
|
public static Dictionary<string, int> Klassifiziere(string hauptcode, string ch1, string ch2, string q1, string q2, int dn)
|
|
{
|
|
AbstractCode? abstractCode = null;
|
|
|
|
Dictionary<string,int> result = new Dictionary<string,int>();
|
|
|
|
switch(hauptcode)
|
|
{
|
|
case "BAA": abstractCode = new BAA(EGeltungsbereich.biegesteif); break;
|
|
case "BAB": abstractCode = new BAB(); break;
|
|
case "BAC": abstractCode = new BAC(); break;
|
|
case "BAD": abstractCode = new BAD(); break;
|
|
case "BAE": abstractCode = new BAE(); break;
|
|
case "BAF": abstractCode = new BAF(); break;
|
|
case "BAG": abstractCode = new BAG(dn); break;
|
|
case "BAH": abstractCode = new BAH(); break;
|
|
case "BAI": abstractCode = new BAI(); break;
|
|
case "BAJ": abstractCode = new BAJ(); break;
|
|
case "BAK": abstractCode = new BAK(); break;
|
|
case "BAL": abstractCode = new BAL(); break;
|
|
case "BAM": abstractCode = new BAM(); break;
|
|
case "BAN": abstractCode = new BAN(); break;
|
|
case "BAO": abstractCode = new BAO(); break;
|
|
case "BAP": abstractCode = new BAP(); break;
|
|
case "BBA": abstractCode = new BBA(); break;
|
|
case "BBB": abstractCode = new BBB(); break;
|
|
case "BBC": abstractCode = new BBC(); break;
|
|
case "BBD": abstractCode = new BBD(); break;
|
|
case "BBE": abstractCode = new BBE(); break;
|
|
case "BBF": abstractCode = new BBF(); break;
|
|
case "BBG": abstractCode = new BBG(); break;
|
|
case "BBH": abstractCode = new BBH(); break;
|
|
case "BDB": abstractCode = new BDB(); break;
|
|
case "BDE": abstractCode = new BDE(); break;
|
|
}
|
|
|
|
if (abstractCode == null) return result;
|
|
|
|
abstractCode.WriteCH1(ch1);
|
|
abstractCode.WriteCH2(ch2);
|
|
float _q1 = float.Parse(q1);
|
|
//float _q2 = float.Parse(q2);
|
|
abstractCode.WriteQ1(_q1);
|
|
//abstractCode.WriteQ2(_q2);
|
|
|
|
result.Add("D", abstractCode.CalculateDK());
|
|
result.Add("B", abstractCode.CalculateBK());
|
|
result.Add("S", abstractCode.CalculateSK());
|
|
|
|
return result;
|
|
}
|
|
}
|
|
} |