VEXPController.cpp

/*
 * Nomad Instrument Control Software
 *
 * Copyright 2011 Institut Laue-Langevin
 *
 * Licensed under the EUPL, Version 1.1 only (the "License");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at:
 *
 * http://joinup.ec.europa.eu/software/page/eupl
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing permissions and
 * limitations under the Licence.
 */

#include "VEXPController.h"
#include "controllers/common/family/Families.h"

using namespace boost;

namespace vexp {

const string VEXPController::TYPE = "vexp_controller";

VEXPController::VEXPController(const string& name) :
	ExperimentController(name) {

	setFamily(family::HIDDEN);

	as.init(this, NOSAVE, "as");
	bs.init(this, NOSAVE, "bs");
	cs.init(this, NOSAVE, "cs");
	aa.init(this, NOSAVE, "aa");
	bb.init(this, NOSAVE, "bb");
	cc.init(this, NOSAVE, "cc");
	ax.init(this, NOSAVE, "ax");
	ay.init(this, NOSAVE, "ay");
	az.init(this, NOSAVE, "az");
	bx.init(this, NOSAVE, "bx");
	by.init(this, NOSAVE, "by");
	bz.init(this, NOSAVE, "bz");
	u.init(this, NOSAVE, "Umatrix");
	b.init(this, NOSAVE, "Bmatrix");

	qh.init(this, NOSAVE, "qh");
	qk.init(this, NOSAVE, "qk");
	ql.init(this, NOSAVE, "ql");
	en.init(this, NOSAVE, "en");
	qm.init(this, NOSAVE, "qm");

	ki.init(this, NOSAVE, "ki");
	kf.init(this, NOSAVE, "kf");

	a1.init(this, NOSAVE, "a1");
	a2.init(this, NOSAVE, "a2");
	a3.init(this, NOSAVE, "a3");
	a4.init(this, NOSAVE, "a4");
	a5.init(this, NOSAVE, "a5");
	a6.init(this, NOSAVE, "a6");

	calculationStatus.init(this, NOSAVE, "calculation_status");
	errorMessage.init(this, NOSAVE, "error_message");
	moveModel.init(this, SAVE, "move_model");

	tasSettings.init(this, "tas_settings");
	sample.init(this, "sample");
	scattering.init(this, "scattering");
	incidentBeam.init(this, "incident_beam");
	scatteredBeam.init(this, "scattered_beam");

	a1Controller.init(this, "A1");
	a2Controller.init(this, "A2");
	a3Controller.init(this, "A3");
	a4Controller.init(this, "A4");
	a5Controller.init(this, "A5");
	a6Controller.init(this, "A6");
}

VEXPController::VEXPController(const VEXPController& controller) :
	ExperimentController(controller) {
}

VEXPController::~VEXPController() {
}

void VEXPController::updateUMatrix() {
	u.update(sample->uRef());
	u.setSize(sample->uRef.getSize());
	u.sendEvent();
}

void VEXPController::updateBMatrix() {
	b.update(tasSettings->b());
	b.setSize(tasSettings->b.getSize());
	b.sendEvent();
}

void VEXPController::refreshKi(float64 value) {

	// Set the value.
	incidentBeam->calcki = value;

	// calca1, calca2, calcStatus are calculated.
	incidentBeam->calculate(tas::Beam::K_MODE);

	a1 = incidentBeam->calca1();
	a2 = incidentBeam->calca2();

	// Copy the status.
	calculationStatus.set(incidentBeam->calcStatus);

	//cout << "Ki -> status " << incidentBeam->calcStatus() << " " << scatteredBeam->calcStatus() << endl;
}

void VEXPController::refreshKf(float64 value) {

	// Set the value.
	scatteredBeam->calckf = value;

	// calca1, calca2, calcStatus are calculated.
	scatteredBeam->calculate(tas::Beam::K_MODE);

	a5 = scatteredBeam->calca5();
	a6 = scatteredBeam->calca6();

	// Copy the status.
	calculationStatus.set(scatteredBeam->calcStatus);

	//cout << "Kf -> status " << incidentBeam->calcStatus() << " " << scatteredBeam->calcStatus() << endl;
}

void VEXPController::refreshFloat64Property(SimpleProperty<float64>& property, float64 value) {

	// Update the value.
	property = value;
}

void VEXPController::refreshFloat64PropertyToMoveModel(SimpleProperty<float64>& property, float64 value) {

	// Update the value only in case moveModel is true.
	if (moveModel()) {
		property = value;
	}
}

void VEXPController::postConfiguration() {

	// Copy the values.
	as.update(tasSettings->as());
	bs.update(tasSettings->bs());
	cs.update(tasSettings->cs());
	aa.update(tasSettings->aa());
	bb.update(tasSettings->bb());
	cc.update(tasSettings->cc());
	ax.update(tasSettings->ax());
	ay.update(tasSettings->ay());
	az.update(tasSettings->az());
	bx.update(tasSettings->bx());
	by.update(tasSettings->by());
	bz.update(tasSettings->bz());

	updateUMatrix();
	updateBMatrix();

// Not used anymore

//	qh.update(scattering->qh.setpoint());
//	qk.update(scattering->qk.setpoint());
//	ql.update(scattering->ql.setpoint());
//	en.update(scattering->en.setpoint());
//	qm.update(scattering->qm.setpoint());
//
//	ki.update(incidentBeam->ki.setpoint());
//	kf.update(scatteredBeam->kf.setpoint());
//
//	a1.update(a1Controller->position.setpoint());
//	a2.update(a2Controller->position.setpoint());
//	a3.update(a3Controller->position.setpoint());
//	a4.update(a4Controller->position.setpoint());
//	a5.update(a5Controller->position.setpoint());
//	a6.update(a6Controller->position.setpoint());

	// Register the property updaters.
	registerPropertyCopierByUpdate(tasSettings->as, as);
	registerPropertyCopierByUpdate(tasSettings->bs, bs);
	registerPropertyCopierByUpdate(tasSettings->cs, cs);
	registerPropertyCopierByUpdate(tasSettings->aa, aa);
	registerPropertyCopierByUpdate(tasSettings->bb, bb);
	registerPropertyCopierByUpdate(tasSettings->cc, cc);
	registerPropertyCopierByUpdate(tasSettings->ax, ax);
	registerPropertyCopierByUpdate(tasSettings->ay, ay);
	registerPropertyCopierByUpdate(tasSettings->az, az);
	registerPropertyCopierByUpdate(tasSettings->bx, bx);
	registerPropertyCopierByUpdate(tasSettings->by, by);
	registerPropertyCopierByUpdate(tasSettings->bz, bz);

	registerUpdater(sample->uRef, &VEXPController::updateUMatrix, this);
	registerUpdater(sample->b, &VEXPController::updateBMatrix, this);

// Not used anymore

//	registerPropertyCopierByUpdate(scattering->qh.setpoint, qh);
//	registerPropertyCopierByUpdate(scattering->qk.setpoint, qk);
//	registerPropertyCopierByUpdate(scattering->ql.setpoint, ql);
//	registerPropertyCopierByUpdate(scattering->en.setpoint, en);
//	registerPropertyCopierByUpdate(scattering->qm.setpoint, qm);
//
//	registerPropertyCopierByUpdate(incidentBeam->ki.setpoint, ki);
//	registerPropertyCopierByUpdate(scatteredBeam->kf.setpoint, kf);
//
//	registerPropertyCopierByUpdate(a1Controller->position.setpoint, a1);
//	registerPropertyCopierByUpdate(a2Controller->position.setpoint, a2);
//	registerPropertyCopierByUpdate(a3Controller->position.setpoint, a3);
//	registerPropertyCopierByUpdate(a4Controller->position.setpoint, a4);
//	registerPropertyCopierByUpdate(a5Controller->position.setpoint, a5);
//	registerPropertyCopierByUpdate(a6Controller->position.setpoint, a6);
//
//	// Register the refreshers.
//	registerRefresher(qh, &VEXPController::refreshFloat64Property, this, scattering->qh.setpoint);
//	registerRefresher(qk, &VEXPController::refreshFloat64Property, this, scattering->qk.setpoint);
//	registerRefresher(ql, &VEXPController::refreshFloat64Property, this, scattering->ql.setpoint);
//	registerRefresher(en, &VEXPController::refreshFloat64Property, this, scattering->en.setpoint);
//	registerRefresher(qm, &VEXPController::refreshFloat64Property, this, scattering->qm.setpoint);
//
//	registerRefresher(ki, &VEXPController::refreshFloat64Property, this, incidentBeam->ki.setpoint);
//	registerRefresher(kf, &VEXPController::refreshFloat64Property, this, scatteredBeam->kf.setpoint);

	registerRefresher(ax, &VEXPController::refreshFloat64Property, this, tasSettings->ax);
	registerRefresher(ay, &VEXPController::refreshFloat64Property, this, tasSettings->ay);
	registerRefresher(az, &VEXPController::refreshFloat64Property, this, tasSettings->az);
	registerRefresher(bx, &VEXPController::refreshFloat64Property, this, tasSettings->bx);
	registerRefresher(by, &VEXPController::refreshFloat64Property, this, tasSettings->by);
	registerRefresher(bz, &VEXPController::refreshFloat64Property, this, tasSettings->bz);
	registerRefresher(ki, &VEXPController::refreshKi, this);
	registerRefresher(kf, &VEXPController::refreshKf, this);
	registerRefresher(a1, &VEXPController::refreshFloat64PropertyToMoveModel, this, a1Controller->position);
	registerRefresher(a2, &VEXPController::refreshFloat64PropertyToMoveModel, this, a2Controller->position);
	registerRefresher(a3, &VEXPController::refreshFloat64PropertyToMoveModel, this, a3Controller->position);
	registerRefresher(a4, &VEXPController::refreshFloat64PropertyToMoveModel, this, a4Controller->position);
	registerRefresher(a5, &VEXPController::refreshFloat64PropertyToMoveModel, this, a5Controller->position);
	registerRefresher(a6, &VEXPController::refreshFloat64PropertyToMoveModel, this, a6Controller->position);
}

}