ExternalInterfaceFunctionalMockupUnitImportToActuator::ExternalInterfaceFunctionalMockupUnitImportToActuator(const ModelObject& modelObject,
                                                                                                             const std::string& actuatedComponentType,
                                                                                                             const std::string& actuatedComponentControlType,
                                                                                                             const ExternalInterfaceFunctionalMockupUnitImport& fMUFile,
                                                                                                             const std::string& fMUInstanceName,
                                                                                                             const std::string& fMUVariableName,
                                                                                                             double initialValue)
  : ModelObject(ExternalInterfaceFunctionalMockupUnitImportToActuator::iddObjectType(), modelObject.model())
{
  OS_ASSERT(getImpl<detail::ExternalInterfaceFunctionalMockupUnitImportToActuator_Impl>());

  bool ok = setActuatedComponentUnique(modelObject);
  if (!ok) {
    remove();
    LOG_AND_THROW("Unable to set " << briefDescription() << "'s ActuatedComponentUnique to "
      << modelObject.nameString() << ".");
  }
  setActuatedComponentType(actuatedComponentType);
  setActuatedComponentControlType(actuatedComponentControlType);
  ok = setFMUFile(fMUFile);
  if (!ok) {
    remove();
    LOG_AND_THROW("Unable to set " << briefDescription() << "'s FMUFileName to "
      << fMUFile.fMUFileName() << ".");
  }
  setFMUInstanceName(fMUInstanceName);
  setFMUVariableName(fMUVariableName);
  setInitialValue(initialValue);
}
boost::optional<IdfObject> ForwardTranslator::translateExternalInterfaceFunctionalMockupUnitExportToActuator(ExternalInterfaceFunctionalMockupUnitExportToActuator & modelObject)
{
  boost::optional<std::string> s;
  boost::optional<double> d;

  IdfObject idfObject(openstudio::IddObjectType::ExternalInterface_FunctionalMockupUnitExport_To_Actuator);
  m_idfObjects.push_back(idfObject);
  //Name
  s = modelObject.name();
  if (s) {
    idfObject.setName(*s);
  }

  const ModelObject m = modelObject.actuatedComponentUnique();
  idfObject.setString(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::ActuatedComponentUniqueName, m.nameString());

  s = modelObject.actuatedComponentType();
  if (s.is_initialized()) {
    idfObject.setString(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::ActuatedComponentType, s.get());
  }
  s = modelObject.actuatedComponentControlType();
  if (s.is_initialized()) {
    idfObject.setString(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::ActuatedComponentControlType, s.get());
  }
  s = modelObject.fMUVariableName();
  if (s.is_initialized()) {
    idfObject.setString(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::FMUVariableName, s.get());
  }

  d = modelObject.initialValue();
  if (d.is_initialized()) {
    idfObject.setDouble(ExternalInterface_FunctionalMockupUnitExport_To_ActuatorFields::InitialValue, d.get());
  }

  return idfObject;
}