/**
* Load the correctors of the specified type, construct the corresponding corrector agents and
* populate the corrector agent list.
*
* @param correctorAgents the list to which the corrector agents should be added
* @param nodeType the type of corrector nodes to fetch
*/
public void loadCorrectors(final List<CorrectorAgent> correctorAgents, final String nodeType) {
final Map<String, CorrectorSupply> supplyMap = new HashMap<String, CorrectorSupply>();
final List<Dipole> allCorrectors = _sequence.getAllNodesOfType(nodeType);
final List<Dipole> correctors = AcceleratorSeq.filterNodesByStatus(allCorrectors, true);
final Iterator<Dipole> correctorIter = correctors.iterator();
while (correctorIter.hasNext()) {
final Dipole corrector = correctorIter.next();
final MagnetMainSupply supply = corrector.getMainSupply();
if (supply != null) {
final String supplyID = supply.getId();
if (!supplyMap.containsKey(supplyID)) {
supplyMap.put(supplyID, new CorrectorSupply(supply));
}
final CorrectorSupply supplyAgent = supplyMap.get(supplyID);
final CorrectorAgent correctorAgent = new CorrectorAgent(corrector);
supplyAgent.addCorrector(correctorAgent);
_correctorAgents.add(correctorAgent);
}
}
_correctorSupplyMap = supplyMap;
_correctorSupplies = new ArrayList<CorrectorSupply>(supplyMap.values());
Collections.sort(
_correctorSupplies, CorrectorSupply.getFirstCorrectorPositionComparator(_sequence));
}
/**
* Update the data based on the information provided by the data provider.
*
* @param adaptor The adaptor from which to update the data
*/
public void update(final DataAdaptor adaptor) {
if (_correctorSupplyMap != null) {
final List<DataAdaptor> supplyAdaptors = adaptor.childAdaptors("supply");
for (final DataAdaptor supplyAdaptor : supplyAdaptors) {
final String supplyID = supplyAdaptor.stringValue("id");
final CorrectorSupply supply = _correctorSupplyMap.get(supplyID);
if (supply != null) {
if (supplyAdaptor.hasAttribute("enable")) {
final boolean enable = supplyAdaptor.booleanValue("enable");
supply.setEnabled(enable);
}
if (supplyAdaptor.hasAttribute("lowerFieldLimit")) {
supply.setLowerFieldLimit(supplyAdaptor.doubleValue("lowerFieldLimit"));
}
if (supplyAdaptor.hasAttribute("upperFieldLimit")) {
supply.setUpperFieldLimit(supplyAdaptor.doubleValue("upperFieldLimit"));
}
}
}
}
final List<DataAdaptor> bpmAdaptors = adaptor.childAdaptors("bpm");
if (bpmAdaptors != null && bpmAdaptors.size() > 0 && _bpmAgents != null) {
// cache all our bpms so we can access them by ID
final Map<String, BpmAgent> bpmAgentMap = new HashMap<String, BpmAgent>(_bpmAgents.size());
for (final BpmAgent bpmAgent : _bpmAgents) {
bpmAgentMap.put(bpmAgent.getID(), bpmAgent);
}
for (final DataAdaptor bpmAdaptor : bpmAdaptors) {
final String bpmID = bpmAdaptor.stringValue("id");
final BpmAgent bpmAgent = bpmAgentMap.get(bpmID);
if (bpmAgent != null) {
if (bpmAdaptor.hasAttribute("flattenEnable")) {
bpmAgent.setFlattenEnabled(bpmAdaptor.booleanValue("flattenEnable"));
}
}
}
}
final DataAdaptor flattenerAdaptor = adaptor.childAdaptor(Flattener.DATA_LABEL);
if (flattenerAdaptor != null) {
getFlattener().update(flattenerAdaptor);
}
final List<DataAdaptor> orbitSourceAdaptors = adaptor.childAdaptors(OrbitSource.DATA_LABEL);
for (DataAdaptor orbitSourceAdaptor : orbitSourceAdaptors) {
final String type = orbitSourceAdaptor.stringValue("type");
if (type.equals("snapshot")) {
final SnapshotOrbitSource orbitSource =
SnapshotOrbitSource.getInstance(orbitSourceAdaptor, _sequence, _bpmAgents);
addOrbitSource(orbitSource);
}
}
}
/**
* Get the list of horizontal corrector supplies.
*
* @return the list of horizontal corrector supplies
*/
public List<CorrectorSupply> getHorizontalCorrectorSupplies() {
final List<CorrectorSupply> horizontalSupplies =
new ArrayList<CorrectorSupply>(_correctorSupplies.size());
for (CorrectorSupply supply : _correctorSupplies) {
if (supply.isHorizontal()) {
horizontalSupplies.add(supply);
}
}
return horizontalSupplies;
}
/**
* Get the list of vertical corrector supplies.
*
* @return the list of vertical corrector supplies
*/
public List<CorrectorSupply> getVerticalCorrectorSupplies() {
final List<CorrectorSupply> verticalSupplies =
new ArrayList<CorrectorSupply>(_correctorSupplies.size());
for (CorrectorSupply supply : _correctorSupplies) {
if (supply.isVertical()) {
verticalSupplies.add(supply);
}
}
return verticalSupplies;
}
/**
* Get the list of horizontal corrector agents
*
* @return the list of horizontal corrector agents
*/
public List<CorrectorAgent> getHorizontalCorrectorAgents() {
final List<CorrectorAgent> horizontalCorrectorAgents =
new ArrayList<CorrectorAgent>(_correctorAgents.size());
for (CorrectorAgent corrector : _correctorAgents) {
if (corrector.isHorizontal()) {
horizontalCorrectorAgents.add(corrector);
}
}
return horizontalCorrectorAgents;
}
/**
* Get the list of vertical corrector agents
*
* @return the list of vertical corrector agents
*/
public List<CorrectorAgent> getVerticalCorrectorAgents() {
final List<CorrectorAgent> verticalCorrectorAgents =
new ArrayList<CorrectorAgent>(_correctorAgents.size());
for (CorrectorAgent corrector : _correctorAgents) {
if (corrector.isVertical()) {
verticalCorrectorAgents.add(corrector);
}
}
return verticalCorrectorAgents;
}
/**
* Add a new OrbitSource to this model's orbit sources.
*
* @param orbitSource the new orbit source to add
*/
public void addOrbitSource(final OrbitSource orbitSource) {
synchronized (_orbitSources) {
if (!_orbitSources.contains(orbitSource)) {
orbitSource.setSequence(_sequence, _bpmAgents);
_orbitSources.add(orbitSource);
EVENT_PROXY.orbitSourceAdded(this, orbitSource);
}
}
postModification();
}
/**
* Remove an OrbitSource from this model's orbit sources.
*
* @param orbitSource the orbit source to remove.
*/
public void removeOrbitSource(final OrbitSource orbitSource) {
synchronized (_orbitSources) {
_orbitSources.remove(orbitSource);
EVENT_PROXY.orbitSourceRemoved(this, orbitSource);
}
postModification();
}
/** Dispose of this model's resources */
public void dispose() {
setSequence(null);
_orbitSources = null;
MESSAGE_CENTER.removeSource(this, OrbitModelListener.class);
_bpmAgents = null;
AVAILABLE_BPM_AGENTS.clear();
_correctorAgents = null;
}
/** refresh enabled BPMs */
protected void refreshEnabledBPMs(final boolean postChange) {
final List<BpmAgent> bpmAgents = new ArrayList<BpmAgent>(AVAILABLE_BPM_AGENTS.size());
for (final BpmAgent bpmAgent : AVAILABLE_BPM_AGENTS) {
if (bpmAgent.isEnabled()) {
bpmAgents.add(bpmAgent);
}
}
_bpmAgents = new ArrayList<BpmAgent>();
_bpmAgents.addAll(bpmAgents);
if (postChange) {
for (final OrbitSource source : _orbitSources) {
source.setSequence(_sequence, _bpmAgents);
}
EVENT_PROXY.enabledBPMsChanged(this, _bpmAgents);
}
}
/** Load the bpms from the selected sequence and construct the BPM agents. */
public void loadBPMs() {
if (_sequence == null) {
AVAILABLE_BPM_AGENTS.clear();
_bpmAgents = new ArrayList<BpmAgent>();
BEAM_EXCURSION_ORBIT_ADAPTOR.setBPMAgents(_bpmAgents);
} else {
final List<BPM> allBPMs = _sequence.getAllNodesOfType(BPM.s_strType);
final List<BPM> bpms = AcceleratorSeq.filterNodesByStatus(allBPMs, true);
final Iterator<BPM> bpmIter = bpms.iterator();
final List<BpmAgent> bpmAgents = new ArrayList<BpmAgent>(bpms.size());
while (bpmIter.hasNext()) {
final BPM bpm = bpmIter.next();
if (bpm.getValid()) {
bpmAgents.add(new BpmAgent(bpm));
}
}
Collections.sort(bpmAgents, new BPMComparator(_sequence));
BEAM_EXCURSION_ORBIT_ADAPTOR.setBPMAgents(bpmAgents);
AVAILABLE_BPM_AGENTS.clear();
AVAILABLE_BPM_AGENTS.addAll(bpmAgents);
refreshEnabledBPMs(false);
}
}
