package org.signalml.plugin.newartifact.method;
import static org.signalml.plugin.i18n.PluginI18n._;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.util.LinkedList;
import java.util.List;
import org.signalml.domain.signal.samplesource.MultichannelSampleSource;
import org.signalml.method.ComputationException;
import org.signalml.method.MethodExecutionTracker;
import org.signalml.method.TrackableMethod;
import org.signalml.method.iterator.IterableMethod;
import org.signalml.method.iterator.IterableParameter;
import org.signalml.plugin.data.PluginConfigForMethod;
import org.signalml.plugin.exception.PluginException;
import org.signalml.plugin.export.method.BaseMethodData;
import org.signalml.plugin.method.PluginAbstractMethod;
import org.signalml.plugin.newartifact.NewArtifactPlugin;
import org.signalml.plugin.newartifact.data.NewArtifactConstants;
import org.signalml.plugin.newartifact.data.NewArtifactData;
import org.signalml.plugin.newartifact.data.NewArtifactParameters;
import org.signalml.plugin.newartifact.data.NewArtifactResult;
import org.signalml.plugin.newartifact.data.NewArtifactType;
import org.signalml.plugin.newartifact.data.NewIterableSensitivity;
import org.signalml.plugin.newartifact.data.mgr.NewArtifactMgrData;
import org.signalml.plugin.newartifact.logic.mgr.NewArtifactComputationMgr;
import org.signalml.plugin.tool.PluginResourceRepository;
import org.springframework.validation.Errors;
public class NewArtifactMethod extends PluginAbstractMethod implements
TrackableMethod, IterableMethod {
private static final String UID = "a3530db2-cfa5-4eed-be1f-dafc81ee4225";
private static final int[] VERSION = new int[] { 1, 0 };
private final int BLOCK_LENGTH_IN_SECONDS = 4;
private final int SMALL_BLOCK_LENGTH_IN_SECONDS = 1;
private final int TAIL_LENGTH_IN_SECONDS = 2;
private final float SMALL_TAIL_LENGTH_IN_SECONDS = 0.25f;
private final float SLOPE_LENGTH_IN_SECONDS = 0.033f;
@Override
public Object doComputation(Object data, MethodExecutionTracker tracker)
throws ComputationException {
NewArtifactData artifactData = (NewArtifactData) data;
File patientTagFile = new File(new File(artifactData.getProjectPath(),
artifactData.getPatientName()).getAbsolutePath(),
artifactData.getPatientName() + ".lock");
FileChannel channel;
try {
channel = new RandomAccessFile(patientTagFile, "rw").getChannel();
} catch (FileNotFoundException e) {
throw new ComputationException(e);
}
FileLock lock = null;
try {
lock = channel.tryLock();
if (lock == null) {
throw new ComputationException(
"Another Articact Detection is already running");
}
NewArtifactComputationMgr mgr = new NewArtifactComputationMgr();
return mgr.compute(
new NewArtifactMgrData(artifactData, this
.getArtifactConstants(artifactData)), tracker);
} catch (IOException e) {
throw new ComputationException(e);
} finally {
if (lock != null) {
try {
lock.release();
channel.close();
patientTagFile.delete();
} catch (IOException e) {
// do nothing
}
}
}
}
private NewArtifactConstants getArtifactConstants(
NewArtifactData artifactData) {
MultichannelSampleSource sampleSource = artifactData.getSampleSource();
return new NewArtifactConstants(sampleSource.getChannelCount(),
sampleSource.getSamplingFrequency(), artifactData
.getParameters().getPowerGridFrequency(),
this.BLOCK_LENGTH_IN_SECONDS,
this.SMALL_BLOCK_LENGTH_IN_SECONDS,
this.TAIL_LENGTH_IN_SECONDS, this.SMALL_TAIL_LENGTH_IN_SECONDS,
this.SLOPE_LENGTH_IN_SECONDS);
}
@Override
public int getTickerCount() {
return 1;
}
@Override
public void validate(Object dataObj, Errors errors) {
super.validate(dataObj, errors);
if (!errors.hasErrors()) {
NewArtifactData data = (NewArtifactData) dataObj;
data.validate(errors);
}
}
@Override
public String getTickerLabel(int ticker) {
if (ticker == 0) {
return _("Artifact detection");
} else {
throw new IndexOutOfBoundsException("No ticker [" + ticker + "]");
}
}
@Override
public IterableParameter[] getIterableParameters(Object dataObj) {
NewArtifactData data = (NewArtifactData) dataObj;
List<NewIterableSensitivity> list = new LinkedList<NewIterableSensitivity>();
NewArtifactParameters parameters = data.getParameters();
int[] chosenArtifactTypes = parameters.getChosenArtifactTypes();
for (int i = 0; i < chosenArtifactTypes.length; i++) {
if (chosenArtifactTypes[i] != 0) {
list.add(new NewIterableSensitivity(parameters, NewArtifactType
.values()[i]));
}
}
IterableParameter[] arr = new IterableParameter[list.size()];
list.toArray(arr);
return arr;
}
@Override
public Object digestIterationResult(int iteration, Object resultObj) {
NewArtifactResult result = (NewArtifactResult) resultObj;
File tagFile = result.getTagFile();
File iterationTagFile = new File(tagFile.getParentFile(), "iteration_"
+ iteration + "_" + tagFile.getName());
tagFile.renameTo(iterationTagFile);
result.setTagFile(iterationTagFile);
return result;
}
@Override
public BaseMethodData createData() {
return null;
}
@Override
public String getName() {
try {
return ((PluginConfigForMethod) PluginResourceRepository
.GetResource("config", NewArtifactPlugin.class)).getMethodConfig().getMethodName();
} catch (PluginException e) {
return "";
}
}
@Override
public Class<?> getResultClass() {
return NewArtifactResult.class;
}
@Override
public String getUID() {
return UID;
}
@Override
public int[] getVersion() {
return VERSION;
}
@Override
public boolean supportsDataClass(Class<?> clazz) {
return NewArtifactData.class.isAssignableFrom(clazz);
}
}