Diffusion Genome Privacy - SHCS App (ms_access_migration) Browse

MedUnit.java
da652ed24928ms_access_migration

MedUnit.java
View Options

			package framework;

			import io.ClientConnection;
			import io.CommAdapter;
			import io.Writer;

			import java.io.File;
			import java.io.IOException;
			import java.math.BigInteger;
			import java.sql.SQLException;
			import java.util.ArrayList;
			import java.util.Collection;
			import java.util.HashMap;
			import java.util.HashSet;
			import java.util.Set;
			import java.util.logging.Level;
			import java.util.logging.Logger;

			import org.bouncycastle.math.ec.ECCurve;
			import org.bouncycastle.math.ec.ECPoint;

			import utils.ClientProperties;
			import utils.ConfigProperties;
			import utils.ECPointMapSerializer;
			import crypto.elgamal.ECElGamal;
			import database.DBconnectorClient;
			import framework.test.TestName;
			import framework.test.TestResult;
			import framework.test.TestResultEncrypted;


			/**
			* This class processes processes tests and generates reports.
			*
			* @author youssef, raisaro, serrano, weber
			*/
			public class MedUnit {

			private static final Logger LOGGER = Logger.getLogger(MedUnit.class.getName());

			private String pathPDF;
			private String curveName;
			private HashMap<ECPoint, BigInteger> reverseTable;

			private DBconnectorClient connDBMU;
			private ClientConnection connectSPU = null;

			public MedUnit(ClientProperties props, int id) {
			LOGGER.setLevel(Level.FINE);

			this.connDBMU = new DBconnectorClient(props.getConfigMU());
			this.curveName = props.getProperty(ConfigProperties.KEY_CURVE);
			this.connectSPU = new ClientConnection(props.getIpSPU(), props.getPortSPU());
			this.pathPDF = props.getPathPDF();

			ECCurve ecCurve = ECElGamal.getNISTNamedCurve(curveName).getCurve();
			ECPointMapSerializer serializer = new ECPointMapSerializer(ecCurve, props.getReverseTableLoc());
			reverseTable = serializer.readECMap();
			}

			public void createReport(int patientId, ArrayList<TestName> selectedTests, Diagnostic diag) {

			HashMap<Integer, TestName> testNames = mapIdToTest(selectedTests);

			ArrayList<TestResult> results = diag.getResults();

			// create output directory if does not exist
			File pathPDFDir = new File(pathPDF);
			if (!pathPDFDir.exists()) {
			if (!pathPDFDir.mkdir()) {
			LOGGER.log(Level.SEVERE, "Could not create directory: " + pathPDF);
			}
			}

			// filename and filepath
			String filename = patientId + ".pdf";
			String filepath = pathPDF + filename;

			try {
			String[] predictions = new String[results.size()];
			Writer w = null;

			try {
			w = new Writer(filepath);
			} catch (Exception e) {
			LOGGER.log(Level.SEVERE, null, e);
			e.printStackTrace();
			}

			// flattened list for PDF generator
			String[] traits = new String[results.size()];
			String[] group = new String[results.size()];

			for (int i = 0; i < results.size(); i++) {
			TestResult result = results.get(i);
			Integer testId = result.getTestIndex();
			double resultScore = result.getResultStd();

			// run interpreter
			Interpreter interpreter = new Interpreter();
			predictions[i] = interpreter.runInterpretation(testId, resultScore);

			// separate trait and group
			TestName testName = testNames.get(testId);
			traits[i] = testName.getName();
			group[i] = testName.getGroup();
			}

			// generate report as PDF
			w.generatePDFreport(predictions, traits, group, patientId, diag.getHLAs());

			} catch (Exception e) {
			LOGGER.log(Level.SEVERE, null, e);
			e.printStackTrace();
			}

			}

			public Diagnostic runTests(int patientId, Collection<TestName> selectedTests) throws SQLException, IOException {

			// clinical analyzer for test logic
			ClinicalAnalyzer clinicAnalyzer = new ClinicalAnalyzer(connDBMU);

			// clinical engine for test computation
			CommAdapter commHandlerAdapter = new CommAdapter(connectSPU);
			ClinicalEngine clinicEng = new ClinicalEngine(patientId, connDBMU, commHandlerAdapter);
			clinicEng.loadCryptoEngine(curveName, reverseTable);

			// get material
			Set<Integer> requiredTests = clinicAnalyzer.getRequiredTests(selectedTests);
			HashSet<Marker> requiredMarkers = clinicAnalyzer.getMarkerSet(requiredTests);
			HashSet<Integer> requiredCFs = clinicAnalyzer.getClinicalFactorSet(requiredTests);

			TestMaterial material = clinicEng.getMaterial(requiredMarkers, requiredCFs);

			// compute tests
			HashMap<Integer, ArrayList<WeightedMarker>> weightedMarkers = clinicAnalyzer.getWeightedMarkers();
			HashMap<Integer, ArrayList<ClinicalFactor>> clinicalFactors = clinicAnalyzer.getClinicalFactors();
			HashMap<Integer, TestResultEncrypted> encryptedResults = clinicEng.computeTests(requiredTests, material, weightedMarkers, clinicalFactors);

			// decrypt results
			DiagnosticRaw diagRaw = clinicEng.decryptDiagnostic(encryptedResults, material.getEncodedHLAs());

			// analyze raw results
			Diagnostic diag = clinicAnalyzer.analyze(patientId, diagRaw);

			return diag;
			}

			private HashMap<Integer, TestName> mapIdToTest(
			ArrayList<TestName> selectedTests) {

			HashMap<Integer, TestName> map = new HashMap<>();

			for (TestName testName : selectedTests) {
			map.put(Integer.valueOf(testName.getId()), testName);
			}
			return map;
			}

			}

genopri-shcs/project/PPPClient/src/framework/MedUnit.javada652ed24928ms_access_migration

MedUnit.javaView Options

genopri-shcs/project/PPPClient/src/framework/MedUnit.java
da652ed24928ms_access_migration

MedUnit.java
View Options