7-8次PTA总结 - ToB企服应用市场:ToB评测及商务社交产业平台

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
interface CircuitComponent{
double getR();
void calculateOutputVoltage(double inputVoltage);
}
abstract class Circuit_Component implements CircuitComponent{
double r;
double rH_Cut;
String name;
Bank bank;
int hway;
int hfront;
double inputVoltage;
double outputVoltage;
double Voltagedifference;
double current;
double limiteCurrent;
double h1_V;
double middle;
public double getLimiteCurrent() {
return limiteCurrent;
}
public void setCurrent(double current){
this.current = current;
}
public double getCurrent(){
return current;
}
public void setHfront(int hfront) {
this.hfront = hfront;
}
public int getHfront() {
return hfront;
}
public void setVoltagedifference(double voltagedifference) {
Voltagedifference = voltagedifference;
}
public double getVoltagedifference() {
return Voltagedifference;
}
public void setInputVoltage(double inputVoltage) {
this.inputVoltage = inputVoltage;
}
public void setOutputVoltage(double outputVoltage) {
this.outputVoltage = outputVoltage;
}
public double getOutputVoltage() {
return outputVoltage;
}
public double getInputVoltage(){
return inputVoltage;
}
public Circuit_Component(String name) {
this.name=name;
}
public void regulation(String regulation) {}
public double getValue() {
return 0;
}
public void setBank(Bank bank) {
this.bank=bank;
}
public abstract void calculateOutputVoltage(double inputVoltage);
public void operate(double voltage) {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void setTotalLux(T t){}
public double getR() {
return this.r;
}
public void setR(double r) {
this.r=r;
}
public int getHway(){return this.hway;}
public void setHway(int hway){
this.hway=hway;
}
public double getrH_Cut(){
return this.rH_Cut;
}
public void setrH_Cut(double r){
this.rH_Cut=r;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null||getClass() != obj.getClass()) {
return false;
}
Circuit_Component other = (Circuit_Component) obj;
return name != null ? name.equals(other.name):other.name == null;
}
@Override
public int hashCode() {
return name != null ? name.hashCode() : 0;
}
public double getH1_V() {
return h1_V;
}
public void setH1_V(double h1_V) {
this.h1_V = h1_V;
}
public double getMiddle() {
return middle;
}
public void setMiddle(double middle) {
this.middle = middle;
}
}
class PowerSupply extends Circuit_Component{
public PowerSupply(String name) {
super(name);
r=0;
}
private static final int INPUT_VOLTAGE = 220;
@Override
public void calculateOutputVoltage(double inputVoltage) {
setInputVoltage(INPUT_VOLTAGE);
setOutputVoltage(INPUT_VOLTAGE);
}
}
class Ground extends Circuit_Component {
public Ground(String name) {
super(name);
}
@Override
public void calculateOutputVoltage(double inputVoltage) {
setInputVoltage(0);
}
}
class Switch extends Circuit_Component{
private boolean status=false;
public Switch(String component_Input) {
super(component_Input);
this.r=0.000000001;
this.limiteCurrent=20;
}
@Override
public void regulation(String regulation) {
this.status=!status;
}
@Override
public double getValue(){
if (status)return 1;
else return 0;
}
@Override
public void calculateOutputVoltage(double inputVoltage) {
setInputVoltage(inputVoltage);
if(this.status){
setOutputVoltage(inputVoltage);
}
else {
setOutputVoltage(0);
}
}
}
class P extends Circuit_Component{
private boolean status=false;
public P(String component_Input) {
super(component_Input);
this.r=0.000000001;
this.limiteCurrent=10;
}
public void setR(){
if(this.hway==1){
this.r=0.000000001;
}else{
this.r=1e9;
}
}
@Override
public double getR(){
setR();
return this.r;
}
@Override
public void calculateOutputVoltage(double inputVoltage) {}
}
class H extends Circuit_Component {
private boolean status=false;
private int hway=2;
public H(String component_Input) {
super(component_Input);
this.r=0.00000001;
this.rH_Cut=1e9;
this.limiteCurrent=20;
}
public void setRH(){
if(!status){
this.r=5;
}else{
this.r=10;
}
}
public double getValue(){
if (status)return 1;
else return 0;
}
@Override
public int getHway(){
return this.hway;
}
@Override
public void setHway(int hway){
this.hway=hway;
}
public void regulation(String regulation) {
this.status=!status;
}
@Override
public double getR() {
setRH();
if(hway==2&& status){
return 1e9;
}else if(hway==3&& !status){
return 1e9;
}
if(!status)return 5;
else return 10;
}
@Override
public void calculateOutputVoltage(double inputVoltage) {
setInputVoltage(inputVoltage);
}
}
abstract class Governor extends Circuit_Component{
public Governor(String name) {
super(name);
r=0;
}
@Override
public abstract void calculateOutputVoltage(double inputVoltage);
}
class F extends Governor {
private int gear = 0;
public F(String component_Input) {
super(component_Input);
this.limiteCurrent=18;
}
@Override
public double getValue() {
return gear;
}
@Override
public void calculateOutputVoltage(double inputVoltage) {
double changeVoltage = 0;
switch (gear) {
case 0:
changeVoltage = 0;break;
case 1:
changeVoltage = inputVoltage * 0.3;break;
case 2:
changeVoltage = inputVoltage * 0.6;break;
case 3:
changeVoltage = inputVoltage * 0.9;break;
default:break;
}
setOutputVoltage(changeVoltage);
}
@Override
public void regulation(String regulation) {
if ("+".equals(regulation)) {
gear++;
if(gear>=3)gear=3;
} else if ("-".equals(regulation)) {
gear--;
if(gear<=0)gear=0;
}
}
}
class L extends Governor{
private double smoothGear;
public L(String component_Input) {
super(component_Input);
this.smoothGear=0;
this.limiteCurrent=18;
}
@Override
public double getValue() {
return smoothGear;
}
public void setGear(double gear) {
this.smoothGear=gear;
}
@Override
public void regulation(String regulation) {
this.smoothGear=Double.valueOf(regulation);
}
@Override
public void calculateOutputVoltage(double inputVoltage) {
setOutputVoltage(inputVoltage*smoothGear);
}
}
abstract class ElectricalAppliances extends Circuit_Component{
public ElectricalAppliances(String name) {
super(name);
}
int id;
@Override
public void calculateOutputVoltage(double inputVoltage){
setInputVoltage(inputVoltage);
setOutputVoltage(inputVoltage-getVoltagedifference());
}
public abstract void operate(double voltage);
}
class B extends ElectricalAppliances{
private double brightness;
public B(String name) {
super(name);
this.r=10;
this.limiteCurrent=9;
}
public void flash(double voltage) {
if (voltage < 9) {
this.brightness=0;
} else if (voltage >= 219) {
this.brightness=200;
} else {
double brightness = 50 + (voltage - 10) * ((200.0 - 50) / (220 - 10));
this.brightness=brightness;
}
}
@Override
public void operate(double voltage) {
setVoltagedifference(voltage);
flash(voltage);
}
@Override
public double getValue() {
return this.brightness;
}
}
class R extends ElectricalAppliances{
private double light;
public R(String component_Input) {
super(component_Input);
this.r=5;
this.limiteCurrent=5;
}
public void flash(double voltage) {
if (voltage>0.0001) this.light=180;
else this.light=0;
}
@Override
public void operate(double voltage) {
setVoltagedifference(voltage);
flash(voltage);
}
@Override
public double getValue() {
return this.light;
}
}
class D extends ElectricalAppliances{
private double speed;
public D(String component_Input) {
super(component_Input);
this.r=20;
this.limiteCurrent=12;
}
public void calculateSpeed(double voltage) {
double speed = 0;
if (voltage < 79) {
speed = 0;
} else if (voltage >= 149) {
speed = 360;
} else {
speed = 80 + (voltage - 80) * ((360 - 80) / (150 - 80));
}
this.speed=speed;
}
@Override
public void operate(double voltage) {
setVoltagedifference(voltage);
calculateSpeed(voltage);
}
@Override
public double getValue() {
return this.speed;
}
}
class A extends ElectricalAppliances{
private double speed;
public A(String name) {
super(name);
this.r=20;
this.limiteCurrent=14;
}
public void calculateSpeed(double voltage) {
if (voltage >= 80 && voltage < 100) {
this.speed = 80;
} else if (voltage >= 100 && voltage < 120) {
this.speed = 160;
} else if (voltage >= 120 && voltage < 140) {
this.speed = 260;
} else if (voltage >= 140) {
this.speed = 360;
}
}
@Override
public void operate(double voltage) {
setVoltagedifference(voltage);
calculateSpeed(voltage);
}
@Override
public double getValue(){
return this.speed;
}
}
class S extends ElectricalAppliances{
private double curtainPosition=1.0;
private double totalLux=0;
public Bank bank;
public S(String name) {
super(name);
this.r = 15;
this.limiteCurrent=12;
}
public void setBank(Bank bank){
this.bank=bank;
}
@Override
public void setTotalLux(T t) {
for(Circuit_Component component:t.getConcatenationList()){
if(component.getName().startsWith("R")||component.getName().startsWith("B")){
totalLux+=component.getValue();
}else if(component.getName().startsWith("M")){
for(T t1:bank.lookforM(component.getName()).getMList()){
setTotalLux(t1);
}
} else if (component.getName().startsWith("T")) {
setTotalLux((T)component);
}
}
}
@Override
public void operate(double voltage) {
setVoltagedifference(voltage);
if(voltage<0.0001){
curtainPosition = 0;
}else if (voltage < 50&&voltage>0.0001) {
curtainPosition = 1.0;
}else {
if (totalLux < 50) {
curtainPosition = 1.0;
} else if (totalLux < 100) {
curtainPosition = 0.8;
} else if (totalLux < 200) {
curtainPosition = 0.6;
} else if (totalLux < 300) {
curtainPosition = 0.4;
} else if (totalLux < 400) {
curtainPosition = 0.2;
} else {
curtainPosition = 0.0;
}
}
}
@Override
public double getValue(){
return this.curtainPosition;
}
}
class T extends Circuit_Component{
private String name;
private List<Circuit_Component> concatenationList;
private Bank bank;
private double Hstatus = 0;
public T(Bank bank) {
super("null");
this.bank = bank;
concatenationList=new ArrayList<>();
}
public List<Circuit_Component> getConcatenationList() {
return concatenationList;
}
@Override
public void calculateOutputVoltage(double inputVoltage) {}
public String getName() {
return name;
}
public double getR(){
double r = 0;
for(Circuit_Component circuitComponent:concatenationList){
if((this.getHstatus()==2&&circuitComponent.getName().startsWith("R")&&circuitComponent.getValue()==1)||(this.getHstatus()==3&&circuitComponent.getName().startsWith("R")&&circuitComponent.getValue()==0)){
r+=1e9;
}else{
r+=circuitComponent.getR();
}
}
return r;
}
public double getHstatus(){
return Hstatus;
}
public void dataInput(String input) {
String regex = "[a-zA-Z]+\\d+|VCC|GND";;
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
HashSet<String> set = new HashSet<>();
boolean ifBegin=true;
while (matcher.find()) {
String match = matcher.group();
if( !set.contains(match) ) {
if (match.startsWith("T")) {
if (ifBegin) {
this.name = match;
ifBegin = false;
} else {
concatenationList.add(bank.lookforT(match));
set.add(match);
}
} else {
if (match.startsWith("M")) {
concatenationList.add(bank.lookforM(match));
set.add(match);
} else {
concatenationList.add(ComponentItemFactory.createComponent(match));
set.add(match);
}
}
}
}
boolean firstMatchProcessed = false;
String regexH = "H\\d+-\\d+";
Pattern patternH = Pattern.compile(regexH);
Matcher matcherH = patternH.matcher(input);
HashSet<String> setH = new HashSet<>();
while (matcherH.find()) {
String match = matcherH.group();
String[] parts = match.split("-");
if(parts[1].equals("2")){
bank.looker(parts[0],this).setHway(2);
this.Hstatus=2;
}
else if(parts[1].equals("3")){
bank.looker(parts[0],this).setHway(3);
this.Hstatus=3;
}
if(!firstMatchProcessed){
if(parts[1].equals("1")){
bank.looker(parts[0],this).setHfront(1);
}
else if(parts[1].equals("2")||parts[1].equals("3")){
bank.looker(parts[0],this).setHfront(2);
}
firstMatchProcessed=true;
}
}
String regexAll = "[A-GI-Z]\\d+-\\d+";
Pattern patternAll = Pattern.compile(regexAll);
Matcher matcherAll = patternAll.matcher(input);
HashSet<String> setAll = new HashSet<>();
while (matcherAll.find()) {
if(!setAll.contains(matcherAll.group().split("-")[0])) {
String match = matcherAll.group();
String[] parts = match.split("-");
if(parts[1].equals("1")){
bank.looker(parts[0],this).setHway(1);
setAll.add(parts[0]);
}
else if(parts[1].equals("2")){
bank.looker(parts[0],this).setHway(2);
setAll.add(parts[0]);
}
}
}
}
}
class M extends Circuit_Component{
private ArrayList<T> mList= new ArrayList<T>();
private Bank bank;
public M(Bank bank) {
super("null");
this.bank = bank;
}
public ArrayList<T> getMList(){
return this.mList;
}
@Override
public void calculateOutputVoltage(double inputVoltage) {}
public void setData(String input){
String regex = "[a-zA-Z]\\d+";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(input);
// HashSet<String> set = new HashSet<>();
while (matcher.find()) {
String match = matcher.group();
if(match.startsWith("M")){
this.name=match;
}else {
mList.add(bank.lookforT(match));
// set.add(match);
}
}
}
@Override
public double getR() {
double r = 0;
boolean ifCount=true;
for (T t : mList) {
ifCount=true;
if(ifCount) {
double resistance = t.getR();
r += 1 / resistance;
}
}
return 1 / r;
}
}
class Bank {
private List<T> tList;
private List<M> mList;
private Operate operate;
public Bank() {
tList=new ArrayList<>();
mList=new ArrayList<>();
operate=new Operate(this);
}
public List<T> getTList(){
return this.tList;
}
public void setData(Scanner sc,Operate operate){
String input= sc.nextLine();
while (!input.startsWith("end")){
if (input.startsWith("#T")||input.startsWith("#M")){
if(input.startsWith("#T")) {
T t = new T(this);
t.dataInput(input);
tList.add(t);
} else if (input.startsWith("#M")) {
M m=new M(this);
m.setData(input);
mList.add(m);
}
}else{
operate.operate(input);
}
input= sc.nextLine();
}
}
public Circuit_Component looker(String name, T t){
for(Circuit_Component circuitComponent: t.getConcatenationList()){
String names= circuitComponent.getName();
if(names.startsWith("M")){
for(T t1:lookforM(names).getMList()){
if (looker(name,t1)==null)continue;
else return looker(name,t1);
}
}else if(names.startsWith("T")){
if (looker(name,(T)circuitComponent)==null)continue;
else return looker(name,(T)circuitComponent);
}else if(name.equals(names)){
return circuitComponent;
}
}
return null;
}
public void operatorH(String name, T t){
for(Circuit_Component circuitComponent: t.getConcatenationList()){
String names= circuitComponent.getName();
if(names.startsWith("M")){
for(T t1:lookforM(names).getMList()){
operatorH(name,t1);
}
}else if(names.startsWith("T")){
operatorH(name,(T)circuitComponent);
}else if(name.equals(names)){
circuitComponent.regulation("");
}
}
}
public List<Circuit_Component> sortArrayOutput(T t, List<Circuit_Component> list){
for(Circuit_Component circuitComponent:t.getConcatenationList()){
String name=circuitComponent.getName();
if(!name.equals("VCC")&&!name.equals("GND")){
if (name.startsWith("M")){
for(T t1:lookforM(name).getMList()){
sortArrayOutput(t1,list);
}
}else if(name.startsWith("T")){
sortArrayOutput((T)circuitComponent,list);
}else{
list.add(circuitComponent);
}
}
}
return list;
}
public T lookforT(String input){
for(T t:tList){
if(t.getName().equals(input)){
return t;
}
}
return null;
}
public M lookforM(String input){
for(M m:mList){
if(m.getName().equals(input)){
return m;
}
}
return null;
}
}
class Operate{
private Bank bank;
public Operate(Bank bank){
this.bank=bank;
}
public void operate(String input) {
int index = input.indexOf('#');
if(input.startsWith("#K")){
if(bank.looker(input.replace("#", ""),bank.getTList().get(bank.getTList().size()-1))!=null){
bank.looker(input.replace("#", ""),bank.getTList().get(bank.getTList().size()-1)).regulation("");
}
} else if (input.startsWith("#H")) {
bank.operatorH(input.replace("#", ""),bank.getTList().get(bank.getTList().size()-1));
} else if (input.startsWith("#L")) {
int startIndex = input.indexOf("#") + 1;
int colonIndex = input.indexOf(":");
String l1 = input.substring(startIndex, colonIndex);
String value = input.substring(colonIndex + 1);
bank.looker(l1,bank.getTList().get(bank.getTList().size()-1)).regulation(value);
} else if (input.startsWith("#F")) {
Pattern pattern = Pattern.compile("#(F\\d+)([\\-+])");
Matcher matcher = pattern.matcher(input);
if (matcher.find()) {
String fNumber = matcher.group(1);
String operators = matcher.group(2);
bank.looker(fNumber,bank.getTList().get(bank.getTList().size()-1)).regulation(operators);
}
}
}
}
class ComponentComparator implements Comparator<Circuit_Component> {
List<String> order = Arrays.asList("K", "F", "L", "B", "R", "D", "A", "H", "S","P");
@Override
public int compare(Circuit_Component o1, Circuit_Component o2) {
String name1 = o1.getName();
String name2 = o2.getName();
String prefix1 = name1.substring(0, 1);
String prefix2 = name2.substring(0, 1);
int index1 = order.indexOf(prefix1);
int index2 = order.indexOf(prefix2);
if (index1 != index2) {
return Integer.compare(index1, index2);
} else {
String number1 = name1.substring(1);
String number2 = name2.substring(1);
return number1.compareTo(number2);
}
}
}
class ComponentVoltage {
public ComponentVoltage() {
}
}
class ComponentVoltage2 extends ComponentVoltage {
private double voltagePin1;
private double voltagePin2;
public ComponentVoltage2(double voltagePin1, double voltagePin2) {
super();
this.voltagePin1 = voltagePin1;
this.voltagePin2 = voltagePin2;
}
public double getVoltagePin1() {
return voltagePin1;
}
public double getVoltagePin2() {
return voltagePin2;
}
@Override
public String toString() {
return "Pin1: " + voltagePin1 + ", Pin2: " + voltagePin2;
}
}
class ComponentVoltage3 extends ComponentVoltage {
private double voltagePin1;
private double voltagePin2;
private double voltagePin3;
public ComponentVoltage3(double voltagePin1, double voltagePin2,double voltagePin3) {
super();
this.voltagePin1 = voltagePin1;
this.voltagePin2 = voltagePin2;
this.voltagePin3 = voltagePin3;
}
public double getVoltagePin1() {
return voltagePin1;
}
public double getVoltagePin2() {
return voltagePin2;
}
public double getVoltagePin3() {
return voltagePin3;
}
@Override
public String toString() {
return "Pin1: " + voltagePin1 + ", Pin2: " + voltagePin2;
}
}
class HomeElectricalSystem {
private static HomeElectricalSystem instance;
private Bank bank;
private Operate operate;
private List<Circuit_Component> list;
private double volatilebefore=220;
private double middle=0;
private double S_V;
private T tLast;
private double h1_V=1;
Map<Circuit_Component, ComponentVoltage> voltageMap = new HashMap<>();
private HomeElectricalSystem() {
this.bank=new Bank();
this.operate=new Operate(bank);
this.list=new ArrayList<>();
}
public static synchronized HomeElectricalSystem getInstance(){
if(instance==null) {
instance=new HomeElectricalSystem();
}
return instance;
}
public void setRAll(T t) {
for (Circuit_Component circuitComponent : t.getConcatenationList()) {
String name = circuitComponent.getName();
if (name.startsWith("K")) {
if (circuitComponent.getValue() == 0) {
circuitComponent.setR(1e9);
}
} else if (name.startsWith("H")) {
if (circuitComponent.getValue() == 0 && circuitComponent.getHway() == 3) {
}
if (circuitComponent.getValue() == 1 && circuitComponent.getHway() == 2) {
break;
}
} else if (name.startsWith("M")) {
for (T t2 : bank.lookforM(name).getMList()) {
setRAll(t2);
}
} else if (name.startsWith("T")) {
setRAll((T)circuitComponent);
}
}
}
public void operateR(T t) {
for (Circuit_Component circuitComponent : t.getConcatenationList()) {
String name = circuitComponent.getName();
if (name.startsWith("S")) {
circuitComponent.setTotalLux(tLast);
circuitComponent.operate(circuitComponent.getVoltagedifference());
} else if (name.startsWith("M")) {
for (T t2 : bank.lookforM(name).getMList()) {
operateR(t2);
}
} else if (name.startsWith("T")) {
operateR((T)circuitComponent);
}
}
}
public Circuit_Component getComponentByName(String desiredName) {
for (Circuit_Component component : voltageMap.keySet()) {
if (component.getName().equals(desiredName)) {
return component;
}
}
return null;
}
public boolean setElectric(double V,T t,boolean ifOperate,double inputVoltage,double output_Voltage, Map<Circuit_Component, ComponentVoltage> voltageMap){
boolean ifCount=true;
if (ifCount&&ifOperate) {
double currentVoltage = inputVoltage;
for (Circuit_Component circuitComponent : t.getConcatenationList()) {
if(circuitComponent.getName().startsWith("P11")){
int a = 1;
}
String name = circuitComponent.getName();
double tR=t.getR();
double circuitR= circuitComponent.getR();
double componentVoltageDrop = 0;
if(circuitR>10000000){
componentVoltageDrop = currentVoltage-output_Voltage;
}else{
componentVoltageDrop = circuitR * V / t.getR();
}
if(!circuitComponent.getName().startsWith("H")){
circuitComponent.setCurrent(V/t.getR());
}
double outputVoltage = currentVoltage - componentVoltageDrop;
if (name.startsWith("M")) {
for (T t1 : bank.lookforM(name).getMList()) {
double Vs=bank.lookforM(name).getR()*V/t.getR();
setElectric(Vs, t1,true,currentVoltage,outputVoltage, voltageMap);
}
} else if(name.startsWith("T")){
double Vs=bank.lookforT(name).getR()*V/t.getR();
setElectric(Vs, (T)circuitComponent,true,currentVoltage,outputVoltage, voltageMap);
}else {
if(circuitComponent.getName().startsWith("S")){
circuitComponent.setBank(bank);
circuitComponent.setVoltagedifference(circuitComponent.getR()*V/t.getR());
}else{
circuitComponent.operate(circuitComponent.getR()*V/t.getR());
}
}
if(!circuitComponent.getName().startsWith("L")&&!circuitComponent.getName().startsWith("F")){
if(circuitComponent.getName().startsWith("H")){
if(circuitComponent.getHfront()==1){
if(voltageMap.containsKey(circuitComponent)){
circuitComponent=getComponentByName(circuitComponent.getName());
}
if(t.getHstatus()==2){
if(circuitComponent.getValue()==0){
circuitComponent.setCurrent(V/t.getR());
}
voltageMap.put(circuitComponent, new ComponentVoltage3(currentVoltage+0.00001, outputVoltage+0.00001,circuitComponent.getMiddle()));
circuitComponent.setMiddle(outputVoltage+0.00001);
}else if(t.getHstatus()==3){
if(circuitComponent.getValue()==1){
circuitComponent.setCurrent(V/t.getR());
}
voltageMap.put(circuitComponent, new ComponentVoltage3(currentVoltage+0.00001,circuitComponent.getMiddle(), outputVoltage+0.00001));
circuitComponent.setMiddle(outputVoltage+0.00001);
}
}else{
if(voltageMap.containsKey(circuitComponent)){
circuitComponent=getComponentByName(circuitComponent.getName());
}
if(t.getHstatus()==2){
if(circuitComponent.getValue()==0){
circuitComponent.setCurrent(V/t.getR());
}
if (outputVoltage<0.00001){
voltageMap.put(circuitComponent, new ComponentVoltage3(circuitComponent.getH1_V(),currentVoltage+0.00001, circuitComponent.getMiddle()));
circuitComponent.setMiddle(currentVoltage+0.00001);
}else{
voltageMap.put(circuitComponent, new ComponentVoltage3(outputVoltage+0.00001,currentVoltage+0.00001, circuitComponent.getMiddle()));
circuitComponent.setMiddle(currentVoltage+0.00001);
circuitComponent.setH1_V(outputVoltage+0.00001);
}
}else if(t.getHstatus()==3){
if(circuitComponent.getValue()==1){
circuitComponent.setCurrent(V/t.getR());
}
if(outputVoltage<0.00001){
voltageMap.put(circuitComponent, new ComponentVoltage3(circuitComponent.getH1_V(),circuitComponent.getMiddle(),currentVoltage+0.00001));
circuitComponent.setMiddle(currentVoltage+0.00001);
}else{
voltageMap.put(circuitComponent, new ComponentVoltage3(outputVoltage+0.00001,circuitComponent.getMiddle(),currentVoltage+0.00001));
circuitComponent.setMiddle(currentVoltage+0.00001);
circuitComponent.setH1_V(outputVoltage+0.00001);
}
}
}
}else{
if(circuitComponent.getHway()==1){
voltageMap.put(circuitComponent, new ComponentVoltage2(currentVoltage+0.00001, outputVoltage+0.00001));
}else{
voltageMap.put(circuitComponent, new ComponentVoltage2(outputVoltage+0.00001, currentVoltage+0.00001));
}
}
}
currentVoltage = outputVoltage;
}
}
return ifCount;
}
public void setPin_V(T t){
for(Circuit_Component circuitComponent: t.getConcatenationList()){
String name = circuitComponent.getName();
if(name.startsWith("K")){
if(circuitComponent.getValue()==0){
circuitComponent.setInputVoltage(t.getInputVoltage());
circuitComponent.setOutputVoltage(t.getOutputVoltage());
}
}
}
}
public void showOut(List<Circuit_Component> list){
List<Circuit_Component> lists=new ArrayList<>();
if(tLast.getR()<0.001){
System.out.println("short circuit error");
}else{
for(Circuit_Component components:list){
ComponentVoltage2 componentVoltage = null;
ComponentVoltage3 componentVoltageH = null;
if(!components.getName().startsWith("H")){
componentVoltage = (ComponentVoltage2) voltageMap.get(components);
}else{
componentVoltageH = (ComponentVoltage3) voltageMap.get(components);
}
if(components.getName().startsWith("K")&&components.getValue()==1) {
if(components.getCurrent()>components.getLimiteCurrent()){
System.out.println("@"+components.getName()+":closed "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2()+" exceeding current limit error");
}else{
System.out.println("@"+components.getName()+":closed "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2());
}
}else if(components.getName().startsWith("K")&&components.getValue()==0) {
if(components.getCurrent()>components.getLimiteCurrent()){
System.out.println("@"+components.getName()+":turned on "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2()+" exceeding current limit error");
}else{
System.out.println("@"+components.getName()+":turned on "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2());
}
}else if(components.getName().startsWith("F")){
if(components.getCurrent()>components.getLimiteCurrent()){
System.out.println("@"+components.getName()+":"+(int)Math.round(components.getValue())+" "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2()+" exceeding current limit error");
}else{
System.out.println("@"+components.getName()+":"+(int)Math.round(components.getValue())+" "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2());
}
}else if(components.getName().startsWith("L")){
if(components.getCurrent()>components.getLimiteCurrent()){
System.out.println("@"+components.getName()+":"+ String.format("%.2f",components.getValue())+" "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2()+" exceeding current limit error");
}else{
System.out.println("@"+components.getName()+":"+ String.format("%.2f",components.getValue())+" "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2());
}
}else if(components.getName().startsWith("H")&&components.getValue()==1) {
if(!ifExitamongList(lists, components.getName())) {
if(components.getCurrent()>components.getLimiteCurrent()){
System.out.println("@" + components.getName() + ":turned on "+(int)componentVoltageH.getVoltagePin1()+"-"+(int)componentVoltageH.getVoltagePin2()+"-"+(int)componentVoltageH.getVoltagePin3()+" exceeding current limit error");
}else{
System.out.println("@" + components.getName() + ":turned on "+(int)componentVoltageH.getVoltagePin1()+"-"+(int)componentVoltageH.getVoltagePin2()+"-"+(int)componentVoltageH.getVoltagePin3());
}
}
}else if(components.getName().startsWith("H")&&components.getValue()==0) {
if(!ifExitamongList(lists, components.getName())) {
if(components.getCurrent()>components.getLimiteCurrent()){
System.out.println("@" + components.getName() + ":closed "+(int)componentVoltageH.getVoltagePin1()+"-"+(int)componentVoltageH.getVoltagePin2()+"-"+(int)componentVoltageH.getVoltagePin3()+" exceeding current limit error");
}else{
System.out.println("@" + components.getName() + ":closed "+(int)componentVoltageH.getVoltagePin1()+"-"+(int)componentVoltageH.getVoltagePin2()+"-"+(int)componentVoltageH.getVoltagePin3());
}
}
}else if(components.getName().startsWith("S")) {
if(components.getCurrent()>components.getLimiteCurrent()){
System.out.println("@" + components.getName() +":"+(int)(components.getValue()*100)+"%"+" "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2()+" exceeding current limit error");
}else{
System.out.println("@" + components.getName() +":"+(int)(components.getValue()*100)+"%"+" "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2());
}
}else if(components.getName().startsWith("P")) {
if(((int)componentVoltage.getVoltagePin1()==0&&(int)componentVoltage.getVoltagePin2()==0)||((int)componentVoltage.getVoltagePin2()-(int)componentVoltage.getVoltagePin1()!=0)){
if(components.getHway()==2){
if(components.getCurrent()>components.getLimiteCurrent()){
System.out.println("@" + components.getName() +":"+"cutoff"+" "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2()+" exceeding current limit error");
}else{
System.out.println("@" + components.getName() +":"+"cutoff"+" "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2());
}
}else{
if(components.getCurrent()>components.getLimiteCurrent()){
System.out.println("@" + components.getName() +":"+"conduction"+" "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2()+" exceeding current limit error");
}else{
System.out.println("@" + components.getName() +":"+"conduction"+" "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2());
}
}
}else if((int)componentVoltage.getVoltagePin1()==(int)componentVoltage.getVoltagePin2()){
if(components.getCurrent()>components.getLimiteCurrent()){
System.out.println("@" + components.getName() +":"+"conduction"+" "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2()+" exceeding current limit error");
}else{
System.out.println("@" + components.getName() +":"+"conduction"+" "+(int)componentVoltage.getVoltagePin1()+"-"+(int)componentVoltage.getVoltagePin2());
}
}
}else if(components.getName().startsWith("B")){
if (components.getCurrent() > components.getLimiteCurrent()) {
System.out.println("@" + components.getName() + ":" + (int) components.getValue() + " " + (int) componentVoltage.getVoltagePin1() + "-" + (int) componentVoltage.getVoltagePin2() + " exceeding current limit error");
} else {
System.out.println("@" + components.getName() + ":" + (int) components.getValue() + " " + (int) componentVoltage.getVoltagePin1() + "-" + (int) componentVoltage.getVoltagePin2());
}
}else if(components.getName().startsWith("D")){
if (components.getCurrent() > components.getLimiteCurrent()) {
System.out.println("@" + components.getName() + ":" + (int) Math.round(components.getValue()-0.1) + " " + (int) componentVoltage.getVoltagePin1() + "-" + (int) componentVoltage.getVoltagePin2() + " exceeding current limit error");
} else {
System.out.println("@" + components.getName() + ":" + (int) Math.round(components.getValue()-0.1) + " " + (int) componentVoltage.getVoltagePin1() + "-" + (int) componentVoltage.getVoltagePin2());
}
}else{
if (components.getCurrent() > components.getLimiteCurrent()) {
System.out.println("@" + components.getName() + ":" + (int) Math.round(components.getValue()) + " " + (int) componentVoltage.getVoltagePin1() + "-" + (int) componentVoltage.getVoltagePin2() + " exceeding current limit error");
} else {
System.out.println("@" + components.getName() + ":" + (int)Math.round(components.getValue()) + " " + (int) componentVoltage.getVoltagePin1() + "-" + (int) componentVoltage.getVoltagePin2());
}
}
lists.add(components);
}
}
}
public boolean ifExitamongList(List<Circuit_Component> list,String name){
for(Circuit_Component components:list){
if(components.getName().equals(name))return true;
}
return false;
}
public void TakeIn(Scanner scanner) {
bank.setData(scanner,operate);
double Vinput=220;
if(bank.getTList().get(bank.getTList().size()-1).getConcatenationList().get(1).getName().startsWith("F")||bank.getTList().get(bank.getTList().size()-1).getConcatenationList().get(1).getName().startsWith("L")){
bank.getTList().get(bank.getTList().size()-1).getConcatenationList().get(1).calculateOutputVoltage(220);
Vinput=bank.getTList().get(bank.getTList().size()-1).getConcatenationList().get(1).getOutputVoltage();
}
bank.getTList().get(bank.getTList().size()-1).setInputVoltage(220);
setRAll(bank.getTList().get(bank.getTList().size()-1));
if (Vinput!=0){
Circuit_Component component=bank.getTList().get(bank.getTList().size()-1).getConcatenationList().get(1);
voltageMap.put(component, new ComponentVoltage2(220,bank.getTList().get(bank.getTList().size()-1).getConcatenationList().get(1).getOutputVoltage()));
setElectric(Vinput,bank.getTList().get(bank.getTList().size()-1),true,Vinput,0,voltageMap);
}
tLast=bank.getTList().get(bank.getTList().size()-1);
operateR(tLast);
list=bank.sortArrayOutput(bank.getTList().get(bank.getTList().size()-1),list);
Collections.sort(list, new ComponentComparator());
showOut(list);
}
}
class ComponentItemFactory{
public static Circuit_Component createComponent(String component_Input) {
if(component_Input.startsWith("VCC")) {
return new PowerSupply(component_Input);
} else if (component_Input.startsWith("GND")) {
return new Ground("GND");
} else if(component_Input.startsWith("K")) {
return new Switch(component_Input);
}else if(component_Input.startsWith("H")) {
return new H(component_Input);
}else if(component_Input.startsWith("F")) {
return new F(component_Input);
}else if(component_Input.startsWith("L")) {
return new L(component_Input);
}else if(component_Input.startsWith("B")) {
return new B(component_Input);
}else if(component_Input.startsWith("R")) {
return new R(component_Input);
}else if(component_Input.startsWith("D")) {
return new D(component_Input);
}else if(component_Input.startsWith("S")) {
return new S(component_Input);
}else if(component_Input.startsWith("A")){
return new A(component_Input);
} else if (component_Input.startsWith("P")) {
return new P(component_Input);
}
return null;
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
HomeElectricalSystem system=HomeElectricalSystem.getInstance();
system.TakeIn(scanner);
}
}

复制代码