void Scene::arm()
{
m_channels.clear();
/* Scenes cannot run unless they are children of Doc */
Doc* doc = qobject_cast <Doc*> (parent());
Q_ASSERT(doc != NULL);
/* Get exact address numbers from fixtures and fixate them to this
scene for running. */
QListIterator <SceneValue> it(m_values);
while (it.hasNext() == true)
{
SceneValue scv(it.next());
Fixture* fxi = doc->fixture(scv.fxi);
Q_ASSERT(fxi != NULL);
SceneChannel channel;
channel.address = fxi->universeAddress() + scv.channel;
channel.target = scv.value;
m_channels.append(channel);
}
}
uchar Scene::value(quint32 fxi, quint32 ch)
{
SceneValue scv(fxi, ch, 0);
int index = m_values.indexOf(scv);
if (index == -1)
return 0;
else
return m_values.at(index).value;
}
t_value Scene::value(t_fixture_id fxi, t_channel ch)
{
SceneValue scv(fxi, ch, 0);
int index = m_values.indexOf(scv);
if (index == -1)
return 0;
else
return m_values.at(index).value;
}
bool ChaserStep::saveXML(QDomDocument* doc, QDomElement* root, int stepNumber, bool isSequence) const
{
QDomElement tag;
QDomText text;
/* Step tag */
tag = doc->createElement(KXMLQLCFunctionStep);
root->appendChild(tag);
/* Step number */
tag.setAttribute(KXMLQLCFunctionNumber, stepNumber);
/* Speeds */
tag.setAttribute(KXMLQLCFunctionSpeedFadeIn, fadeIn);
tag.setAttribute(KXMLQLCFunctionSpeedHold, hold);
tag.setAttribute(KXMLQLCFunctionSpeedFadeOut, fadeOut);
//tag.setAttribute(KXMLQLCFunctionSpeedDuration, duration); // deprecated from version 4.3.1
if (note.isEmpty() == false)
tag.setAttribute(KXMLQLCStepNote, note);
if (isSequence)
{
/* it's a sequence step. Save values accordingly */
tag.setAttribute(KXMLQLCSequenceSceneValues, values.count());
QListIterator <SceneValue> it(values);
QString stepValues;
while (it.hasNext() == true)
{
SceneValue scv(it.next());
if (scv.value != 0)
{
if (stepValues.isEmpty() == false)
stepValues.append(QString(","));
stepValues.append(QString("%1,%2,%3").arg(scv.fxi).arg(scv.channel).arg(scv.value));
}
}
if (stepValues.isEmpty() == false)
{
text = doc->createTextNode(stepValues);
tag.appendChild(text);
}
}
else
{
/* Step function ID */
text = doc->createTextNode(QString::number(fid));
tag.appendChild(text);
}
return true;
}
void findImplicit(AstNodeAssign* nodep) {
if (m_assignp) nodep->v3fatalSrc("Found a NodeAssign under another NodeAssign");
m_assignp = nodep;
m_assignError = false;
m_extend = false;
nodep->user1(true);
// Record the LHS Var so we can check if the Var on the RHS is the same
m_lhsVarRefp = findVarRefRecurse(nodep->lhsp());
if (!m_lhsVarRefp) nodep->v3fatalSrc("Couldn't find a VarRef on the LHSP of an Assign");
// Iterate children looking for ArraySel nodes. From that we get the number of elements
// in the array so we know how many times we need to clone this assignment.
nodep->iterateChildren(*this);
if (nodep->user2() > 1) SliceCloneVisitor scv(nodep);
m_assignp = NULL;
}
bool Scene::loadXML(const QDomElement* root)
{
QString str;
QDomNode node;
QDomElement tag;
Q_ASSERT(root != NULL);
if (root->tagName() != KXMLQLCFunction)
{
qWarning("Function node not found!");
return false;
}
/* Load scene contents */
node = root->firstChild();
while (node.isNull() == false)
{
tag = node.toElement();
if (tag.tagName() == KXMLQLCBus)
{
/* Bus */
str = tag.attribute(KXMLQLCBusRole);
Q_ASSERT(str == KXMLQLCBusFade);
setBus(tag.text().toUInt());
}
else if (tag.tagName() == KXMLQLCFunctionValue)
{
/* Channel value */
SceneValue scv(&tag);
if (scv.isValid() == true)
setValue(scv);
}
else
{
qWarning() << "Unknown scene tag:" << tag.tagName();
}
node = node.nextSibling();
}
return true;
}
void SceneValue_Test::save()
{
QDomDocument doc;
QDomElement root;
QDomElement tag;
root = doc.createElement("Test");
SceneValue scv(4, 8, 16);
QVERIFY(scv.saveXML(&doc, &root) == true);
tag = root.firstChild().toElement();
QVERIFY(tag.tagName() == "Value");
QVERIFY(tag.attribute("Fixture").toInt() == 4);
QVERIFY(tag.attribute("Channel").toInt() == 8);
QVERIFY(tag.text().toInt() == 16);
}
void ChannelsGroup::slotFixtureRemoved(quint32 fixtureId)
{
bool hasChanged = false;
QMutableListIterator<SceneValue> channelsIt(m_channels);
while (channelsIt.hasNext())
{
SceneValue scv(channelsIt.next());
if (scv.fxi == fixtureId)
{
channelsIt.remove();
hasChanged = true;
}
}
if (hasChanged)
emit changed(this->id());
}
bool PhraseDictionaryMemory::Load(const std::vector<FactorType> &input
, const std::vector<FactorType> &output
, const string &filePath
, const vector<float> &weight
, size_t tableLimit
, const LMList &languageModels
, float weightWP)
{
const StaticData &staticData = StaticData::Instance();
m_tableLimit = tableLimit;
// data from file
InputFileStream inFile(filePath);
// create hash file if necessary
ofstream tempFile;
string tempFilePath;
vector< vector<string> > phraseVector;
string line, prevSourcePhrase = "";
size_t count = 0;
size_t line_num = 0;
size_t numElement = NOT_FOUND; // 3=old format, 5=async format which include word alignment info
while(getline(inFile, line))
{
++line_num;
vector<string> tokens = TokenizeMultiCharSeparator( line , "|||" );
if (numElement == NOT_FOUND)
{ // init numElement
numElement = tokens.size();
assert(numElement >= 3);
// extended style: source ||| target ||| scores ||| [alignment] ||| [counts]
}
if (tokens.size() != numElement)
{
stringstream strme;
strme << "Syntax error at " << filePath << ":" << line_num;
UserMessage::Add(strme.str());
abort();
}
const string &sourcePhraseString=tokens[0]
,&targetPhraseString=tokens[1]
,&scoreString = tokens[2];
bool isLHSEmpty = (sourcePhraseString.find_first_not_of(" \t", 0) == string::npos);
if (isLHSEmpty && !staticData.IsWordDeletionEnabled()) {
TRACE_ERR( filePath << ":" << line_num << ": pt entry contains empty target, skipping\n");
continue;
}
const std::string& factorDelimiter = StaticData::Instance().GetFactorDelimiter();
if (sourcePhraseString != prevSourcePhrase)
phraseVector = Phrase::Parse(sourcePhraseString, input, factorDelimiter);
vector<float> scoreVector = Tokenize<float>(scoreString);
if (scoreVector.size() != m_numScoreComponent)
{
stringstream strme;
strme << "Size of scoreVector != number (" <<scoreVector.size() << "!=" <<m_numScoreComponent<<") of score components on line " << line_num;
UserMessage::Add(strme.str());
abort();
}
// source
Phrase sourcePhrase(Input);
sourcePhrase.CreateFromString( input, phraseVector);
//target
TargetPhrase targetPhrase(Output);
targetPhrase.SetSourcePhrase(&sourcePhrase);
targetPhrase.CreateFromString( output, targetPhraseString, factorDelimiter);
if (tokens.size() > 3)
targetPhrase.SetAlignmentInfo(tokens[3]);
// component score, for n-best output
std::vector<float> scv(scoreVector.size());
std::transform(scoreVector.begin(),scoreVector.end(),scv.begin(),TransformScore);
std::transform(scv.begin(),scv.end(),scv.begin(),FloorScore);
targetPhrase.SetScore(m_feature, scv, weight, weightWP, languageModels);
AddEquivPhrase(sourcePhrase, targetPhrase);
count++;
}
// sort each target phrase collection
m_collection.Sort(m_tableLimit);
return true;
}
void SceneEditor::init()
{
QToolBar* toolBar;
/* Actions */
m_enableCurrentAction = new QAction(QIcon(":/check.png"),
tr("Enable all channels in current fixture"), this);
m_disableCurrentAction = new QAction(QIcon(":/uncheck.png"),
tr("Disable all channels in current fixture"), this);
m_copyAction = new QAction(QIcon(":/editcopy.png"),
tr("Copy current values to clipboard"), this);
m_pasteAction = new QAction(QIcon(":/editpaste.png"),
tr("Paste clipboard values to current fixture"), this);
m_copyToAllAction = new QAction(QIcon(":/editcopyall.png"),
tr("Copy current values to all fixtures"), this);
m_colorToolAction = new QAction(QIcon(":/color.png"),
tr("Color tool for CMY/RGB-capable fixtures"), this);
connect(m_enableCurrentAction, SIGNAL(triggered(bool)),
this, SLOT(slotEnableCurrent()));
connect(m_disableCurrentAction, SIGNAL(triggered(bool)),
this, SLOT(slotDisableCurrent()));
connect(m_copyAction, SIGNAL(triggered(bool)),
this, SLOT(slotCopy()));
connect(m_pasteAction, SIGNAL(triggered(bool)),
this, SLOT(slotPaste()));
connect(m_copyToAllAction, SIGNAL(triggered(bool)),
this, SLOT(slotCopyToAll()));
connect(m_colorToolAction, SIGNAL(triggered(bool)),
this, SLOT(slotColorTool()));
/* Toolbar */
toolBar = new QToolBar(this);
layout()->setMenuBar(toolBar);
toolBar->addAction(m_enableCurrentAction);
toolBar->addAction(m_disableCurrentAction);
toolBar->addSeparator();
toolBar->addAction(m_copyAction);
toolBar->addAction(m_pasteAction);
toolBar->addAction(m_copyToAllAction);
toolBar->addSeparator();
toolBar->addAction(m_colorToolAction);
/* Tab widget */
connect(m_tab, SIGNAL(currentChanged(int)),
this, SLOT(slotTabChanged(int)));
/* Add & remove buttons */
connect(m_addFixtureButton, SIGNAL(clicked()),
this, SLOT(slotAddFixtureClicked()));
connect(m_removeFixtureButton, SIGNAL(clicked()),
this, SLOT(slotRemoveFixtureClicked()));
m_nameEdit->setText(m_scene->name());
connect(m_nameEdit, SIGNAL(textEdited(const QString&)),
this, SLOT(slotNameEdited(const QString&)));
slotNameEdited(m_scene->name());
/* Bus */
connect(m_busCombo, SIGNAL(activated(int)),
this, SLOT(slotBusComboActivated(int)));
fillBusCombo();
m_initializing = true;
QListIterator <SceneValue> it(m_scene->values());
while (it.hasNext() == true)
{
SceneValue scv(it.next());
if (fixtureItem(scv.fxi) == NULL)
{
Fixture* fixture = _app->doc()->fixture(scv.fxi);
if (fixture == NULL)
continue;
addFixtureItem(fixture);
addFixtureTab(fixture);
}
setSceneValue(scv);
}
m_initializing = false;
}
void DimCRFVGeometry<TDim, TWorldDim>::
update_hanging(GridObject* pElem, const MathVector<worldDim>* vCornerCoords, const ISubsetHandler* ish,bool keepSCV,bool keepSCVF)
{
// If already update for this element, do nothing
if(m_pElem == pElem) return; else m_pElem = pElem;
// get grid
Grid& grid = *(ish->grid());
// refresh local data, if different roid given
if(m_roid != pElem->reference_object_id())
{
// remember new roid
m_roid = (ReferenceObjectID) pElem->reference_object_id();
// update local data
update_local_data();
m_numDofs = num_scv();
}
const LocalShapeFunctionSet<dim>& rTrialSpace =
LocalFiniteElementProvider::get<dim>(m_roid, LFEID(LFEID::CROUZEIX_RAVIART, dim, 1));
// compute barycenter coordinates
globalBary = vCornerCoords[0];
for (size_t j=1;j<m_rRefElem.num(0);j++){
globalBary+=vCornerCoords[j];
}
globalBary*=1./(number)m_rRefElem.num(0);
// compute global informations for scvf
for(size_t i = 0; i < num_scvf(); ++i)
{
for (size_t j=0;j<m_vSCVF[i].numCo-1;j++){
m_vSCVF[i].vGloPos[j]=vCornerCoords[m_rRefElem.id(dim-2,i,0,j)];
}
m_vSCVF[i].vGloPos[m_vSCVF[i].numCo-1]=globalBary;
AveragePositions(m_vSCVF[i].globalIP, m_vSCVF[i].vGloPos, m_vSCVF[i].numCo);
ElementNormal<face_type0,worldDim>(m_vSCVF[i].Normal,m_vSCVF[i].vGloPos);// face_type0 identical to scvf type
}
// compute size of scv
for(size_t i = 0; i < num_scv(); ++i)
{
// side nodes in reverse order to fulfill standard element order
for (int j=0;j<m_vSCV[i].numCorners-1;j++){
m_vSCV[i].vGloPos[m_vSCV[i].numCorners-2-j]=vCornerCoords[m_rRefElem.id(dim-1,i,0,j)];
}
AveragePositions(m_vGlobUnkCoords[i], m_vSCV[i].vGloPos, m_vSCV[i].numCorners-1);
m_vSCV[i].vGlobIP = m_vGlobUnkCoords[i];
m_vSCV[i].vGloPos[m_vSCV[i].numCorners-1]=globalBary;
// compute volume of scv and normal to associated element face
//CRSCVSizeAndNormal<dim>(m_vSCV[i].Vol,m_vSCV[i].Normal,m_vSCV[i].vGloPos,m_vSCV[i].numCorners);
if (m_vSCV[i].numCorners-1==dim){
m_vSCV[i].Vol = ElementSize<scv_type0,worldDim>(m_vSCV[i].vGloPos);
ElementNormal<face_type0, worldDim>(m_vSCV[i].Normal, m_vSCV[i].vGloPos);
} else { // m_vSCV[i].numCorners-2==dim , only possible in 3d (pyramid)
m_vSCV[i].Vol = ElementSize<scv_type1,worldDim>(m_vSCV[i].vGloPos);
ElementNormal<face_type1,worldDim>(m_vSCV[i].Normal, m_vSCV[i].vGloPos);
};
// nodes are in reverse order therefore reverse sign to get outward normal
m_vSCV[i].Normal*=-1;
}
// get reference mapping
DimReferenceMapping<dim, worldDim>& rMapping = ReferenceMappingProvider::get<dim, worldDim>(m_roid);
rMapping.update(vCornerCoords);
// check for hanging nodes
if (dim==2){
std::vector<Edge*> vEdges;
CollectEdgesSorted(vEdges, grid, pElem);
for(size_t side = 0; side < vEdges.size(); ++side){
ConstrainingEdge* constrainingObj = dynamic_cast<ConstrainingEdge*>(vEdges[side]);
if(constrainingObj == NULL) continue;
// found constraining edge
MathVector<worldDim> globalMidpoint = m_vSCV[side].vGlobIP;
MathVector<dim> localMidpoint = m_vSCV[side].vLocIP;
// get edge corners
size_t edgeCo[2];
for (size_t j=0;j<2;j++) edgeCo[j] = m_rRefElem.id(1,side,0,j);
// compute dof positions on constraining edge,
// replace dof "side" with first and insert second at the end
// set up new scvs
// keepSCV parameter specifies if scv "side" gets replaced by new one
size_t ind=side;
size_t keepOffset=0;
MathVector<worldDim> normal = m_vSCV[side].Normal;
normal*=0.5;
number vol = 0.5*m_vSCV[side].Vol;
if (keepSCV){
ind=m_numSCV+1;
keepOffset=1;
}
for (int d=0;d<worldDim;d++)
m_vGlobUnkCoords[ind][d] = 0.5 * (vCornerCoords[edgeCo[0]][d] + globalMidpoint[d]);
for (int d=0;d<dim;d++)
m_vLocUnkCoords[ind][d] = 0.5 * (m_rRefElem.corner(edgeCo[0])[d] + localMidpoint[d]);
for (int d=0;d<worldDim;d++)
m_vGlobUnkCoords[m_numSCV][d] = 0.5 * (vCornerCoords[edgeCo[1]][d] + globalMidpoint[d]);
for (int d=0;d<dim;d++)
m_vLocUnkCoords[m_numSCV][d] = 0.5 * (m_rRefElem.corner(edgeCo[1])[d] + localMidpoint[d]);
// handle corresponding scvfs
// if keepSCVF copy them into constrained scvf array
if (keepSCVF){
for (size_t j=0;j<2;j++){
m_vConstrainedSCVF[m_numConstrainedSCVF+j] = m_vSCVF[edgeCo[j]];
if (m_vConstrainedSCVF[edgeCo[j]].To==side){
m_vConstrainedSCVF[edgeCo[j]].From=side;
m_vConstrainedSCVF[edgeCo[j]].Normal*=-1;
}
}
m_numConstrainedSCVF += 2;
}
for (size_t j=0;j<2;j++){
if (m_vSCVF[edgeCo[j]].From==side) m_vSCVF[edgeCo[j]].From=m_numDofs+j;
if (m_vSCVF[edgeCo[j]].To==side) m_vSCVF[edgeCo[j]].To=m_numDofs+j;
}
m_vSCV[ind].Normal = normal;
m_vSCV[ind].Vol = vol;
m_vSCV[ind].nodeID = m_numDofs;
m_vSCV[ind].vGlobIP = m_vGlobUnkCoords[ind];
m_vSCV[ind].vLocIP = m_vLocUnkCoords[ind];
m_vSCV[ind].numSH = rTrialSpace.num_sh();
m_vSCV[ind].vGloPos[0]=vCornerCoords[edgeCo[0]];
m_vSCV[ind].vGloPos[1]=globalMidpoint;
m_vSCV[ind].vGloPos[2]=globalBary;
m_vSCV[ind].vLocPos[0]=m_rRefElem.corner(edgeCo[0]);
m_vSCV[ind].vLocPos[1]=localMidpoint;
m_vSCV[ind].vLocPos[2]=localBary;
m_vSCV[ind].numCorners = 3;
rTrialSpace.shapes(&(m_vSCV[ind].vShape[0]), m_vSCV[ind].local_ip());
rTrialSpace.grads(&(m_vSCV[ind].vLocalGrad[0]), m_vSCV[ind].local_ip());
// second scv inserted at the end
m_vSCV[m_numSCV].Normal = normal;
m_vSCV[m_numSCV].Vol = vol;
m_vSCV[m_numSCV].nodeID = m_numDofs+1;
m_vSCV[m_numSCV].vGlobIP = m_vGlobUnkCoords[m_numSCV];
m_vSCV[m_numSCV].vLocIP = m_vLocUnkCoords[m_numSCV];
m_vSCV[m_numSCV].numSH = rTrialSpace.num_sh();
m_vSCV[m_numSCV].vGloPos[0]=vCornerCoords[edgeCo[1]];
m_vSCV[m_numSCV].vGloPos[1]=globalMidpoint;
m_vSCV[m_numSCV].vGloPos[2]=globalBary;
m_vSCV[m_numSCV].vLocPos[0]=m_rRefElem.corner(edgeCo[1]);
m_vSCV[m_numSCV].vLocPos[1]=localMidpoint;
m_vSCV[m_numSCV].vLocPos[2]=localBary;
m_vSCV[m_numSCV].numCorners = 3;
rTrialSpace.shapes(&(m_vSCV[m_numSCV].vShape[0]), m_vSCV[m_numSCV].local_ip());
rTrialSpace.grads(&(m_vSCV[m_numSCV].vLocalGrad[0]), m_vSCV[m_numSCV].local_ip());
// insert new scvf
m_vSCVF[m_numSCVF].From = m_numDofs;
m_vSCVF[m_numSCVF].To = m_numDofs+1;
m_vSCVF[m_numSCVF].vLocPos[0] = localMidpoint;
m_vSCVF[m_numSCVF].vLocPos[1] = localBary;
m_vSCVF[m_numSCVF].vGloPos[0] = globalMidpoint;
m_vSCVF[m_numSCVF].vGloPos[1] = globalBary;
m_vSCVF[m_numSCVF].numSH = rTrialSpace.num_sh();
for (int d=0;d<dim;d++) m_vSCVF[m_numSCVF].localIP[d] = 0.5*(localMidpoint[d] + localBary[d]);
for (int d=0;d<worldDim;d++) m_vSCVF[m_numSCVF].globalIP[d] = 0.5*(globalMidpoint[d] + globalBary[d]);
rTrialSpace.shapes(&(m_vSCVF[m_numSCVF].vShape[0]), m_vSCVF[m_numSCVF].local_ip());
rTrialSpace.grads(&(m_vSCVF[m_numSCVF].vLocalGrad[0]), m_vSCVF[m_numSCVF].local_ip());
ElementNormal<face_type0,worldDim>(m_vSCVF[m_numSCVF].Normal,m_vSCVF[m_numSCVF].vGloPos);
// insert new constrained dof object
m_vCD[m_numConstrainedDofs].i = side;
m_vCD[m_numConstrainedDofs].numConstrainingDofs = 2;
m_vCD[m_numConstrainedDofs].cDofInd[0] = m_numDofs;
m_vCD[m_numConstrainedDofs].cDofInd[1] = m_numDofs+1;
m_vCD[m_numConstrainedDofs].cDofWeights[0] = 0.5;
m_vCD[m_numConstrainedDofs].cDofWeights[1] = 0.5;
m_numSCV+=1+keepOffset;
m_numSCVF+=1;
m_numDofs+=2;
m_numConstrainedDofs+=1;
m_roid = ROID_UNKNOWN;
}
} else {
// dim == 3
std::vector<Face*> vFaces;
CollectFacesSorted(vFaces, grid, pElem);
handledEdges.clear();
for(size_t face = 0; face < vFaces.size(); ++face){
ConstrainingFace* constrainingObj = dynamic_cast<ConstrainingFace*>(vFaces[face]);
if(constrainingObj == NULL) continue;
// found constraining face
MathVector<worldDim> globalMidpoint = m_vSCV[face].vGlobIP;
MathVector<dim> localMidpoint = m_vSCV[face].vLocIP;
number faceVol = m_vSCV[face].Vol;
MathVector<worldDim> faceNormal = m_vSCV[face].Normal;
// get face corners and edges
size_t faceCo[4];
size_t faceEdge[4];
// number of corners of face = number of edges
size_t numFaceCo = m_rRefElem.num(2,face,0);
for (size_t j=0;j<numFaceCo;j++) faceCo[j] = m_rRefElem.id(2,face,0,j);
for (size_t j=0;j<numFaceCo;j++) faceEdge[j] = m_rRefElem.id(2,face,1,j);
number volSum=0;
size_t keepOffset=0;
if (keepSCV) keepOffset=1;
// compute coordinates of each face and fill scv values
for (size_t i=0;i<numFaceCo;i++){
size_t co = faceCo[i];
size_t nOfEdges=0;
size_t nbEdges[2];
// find 2 edges in face belonging to node
for (size_t j=0;j<m_rRefElem.num(0,co,1);j++){
size_t candidate = m_rRefElem.id(0,co,1,j);
bool found = false;
for (size_t k=0;k<numFaceCo;k++){
if (faceEdge[k]==candidate){
found = true;
break;
}
}
if (found==true){
nbEdges[nOfEdges] = candidate;
nOfEdges++;
if (nOfEdges==2) break;
}
}
// in triangular case switch edges if necessary for correct orientation
if (numFaceCo==3){
if (faceEdge[i]==nbEdges[1]){
nbEdges[1] = nbEdges[0];
nbEdges[0] = faceEdge[i];
}
}
// keepSCV parameter specifies if scv "side" gets replaced by new one
size_t ind = m_numSCV+i-1+keepOffset;
if (i==0){
if (keepSCV) ind=m_numSCV;
else ind = face;
}
// others are inserted at the end
m_vSCV[ind].vGloPos[0] = vCornerCoords[co];
m_vSCV[ind].vLocPos[0] = m_rRefElem.corner(co);
for (int d=0;d<worldDim;d++){
// edge 0 midpoint
m_vSCV[ind].vGloPos[1][d] = 0.5 * ( vCornerCoords[m_rRefElem.id(1,nbEdges[0],0,0)][d] + vCornerCoords[m_rRefElem.id(1,nbEdges[0],0,1)][d] );
m_vSCV[ind].vLocPos[1][d] = 0.5 * ( m_rRefElem.corner(m_rRefElem.id(1,nbEdges[0],0,0))[d] + m_rRefElem.corner(m_rRefElem.id(1,nbEdges[0],0,1))[d] );
// edge 1 midpoint
m_vSCV[ind].vGloPos[numFaceCo-1][d] = 0.5 * ( vCornerCoords[m_rRefElem.id(1,nbEdges[1],0,0)][d] + vCornerCoords[m_rRefElem.id(1,nbEdges[1],0,1)][d] );
m_vSCV[ind].vLocPos[numFaceCo-1][d] = 0.5 * ( m_rRefElem.corner(m_rRefElem.id(1,nbEdges[1],0,0))[d] + m_rRefElem.corner(m_rRefElem.id(1,nbEdges[1],0,1))[d] );
}
if (numFaceCo==4) m_vSCV[ind].vGloPos[2] = globalMidpoint;
m_vSCV[ind].vGloPos[numFaceCo] = globalBary;
m_vSCV[ind].vLocPos[numFaceCo] = localBary;
m_vSCV[ind].numCorners = numFaceCo + 1;
AveragePositions(m_vGlobUnkCoords[ind], m_vSCV[ind].vGloPos, m_vSCV[ind].numCorners-1);
AveragePositions(m_vLocUnkCoords[ind], m_vSCV[ind].vLocPos, m_vSCV[ind].numCorners-1);
m_vSCV[ind].vLocIP = m_vLocUnkCoords[ind];
m_vSCV[ind].vGlobIP = m_vGlobUnkCoords[ind];
m_vSCV[ind].numSH = rTrialSpace.num_sh();
if (numFaceCo==3) m_vSCV[ind].Vol = ElementSize<scv_type0,worldDim>(m_vSCV[ind].vGloPos);
else m_vSCV[ind].Vol = ElementSize<scv_type1,worldDim>(m_vSCV[ind].vGloPos);
if (m_vSCV[ind].Vol<0) m_vSCV[ind].Vol *= -1;
volSum+=m_vSCV[ind].Vol;
m_vSCV[ind].Normal = faceNormal;
m_vSCV[ind].Normal *= (number) m_vSCV[ind].Vol / faceVol;
rTrialSpace.shapes(&(m_vSCV[ind].vShape[0]), m_vSCV[ind].local_ip());
rTrialSpace.grads(&(m_vSCV[ind].vLocalGrad[0]), m_vSCV[ind].local_ip());
m_vSCV[ind].nodeID = m_numDofs+i;
}
// compute inner scv in triangular case
if (numFaceCo==3){
size_t ind = m_numSCV+2+keepOffset;
m_vSCV[ind].Vol = faceVol - volSum;
m_vSCV[ind].nodeID=m_numDofs+3;
m_vSCV[ind].Normal = faceNormal;
m_vSCV[ind].Normal *= (number) m_vSCV[ind].Vol / faceVol;
m_vSCV[ind].vGlobIP = m_vSCV[face].vGloPos[1];
m_vSCV[ind].vLocIP = m_vSCV[face].vLocPos[1];
for (size_t j=0;j<2;j++){
m_vSCV[ind].vGlobIP += m_vSCV[m_numSCV+j].vGloPos[1];
m_vSCV[ind].vLocIP += m_vSCV[m_numSCV+j].vLocPos[1];
}
m_vSCV[ind].vGlobIP *= (number)1.0/3.0;
m_vSCV[ind].vLocIP *= (number)1.0/3.0;
m_vGlobUnkCoords[ind] = m_vSCV[ind].vGlobIP;
m_vLocUnkCoords[ind] = m_vSCV[ind].vLocIP;
m_vSCV[ind].numCorners = numFaceCo + 1;
m_vSCV[ind].numSH = rTrialSpace.num_sh();
rTrialSpace.shapes(&(m_vSCV[ind].vShape[0]), m_vSCV[ind].local_ip());
rTrialSpace.grads(&(m_vSCV[ind].vLocalGrad[0]), m_vSCV[ind].local_ip());
}
// copy scvfs into constrained scvfs
if (keepSCVF){
for (size_t i=0;i<numFaceCo;i++){
size_t edge = faceEdge[i];
m_vConstrainedSCVF[m_numConstrainedSCVF+i] = m_vSCVF[edge];
if (m_vConstrainedSCVF[m_numConstrainedSCVF+i].To==face){
m_vConstrainedSCVF[m_numConstrainedSCVF+i].From=face;
m_vConstrainedSCVF[m_numConstrainedSCVF+i].Normal*=-1;
}
}
m_numConstrainedSCVF += numFaceCo;
}
// insert new scvfs, first the ones associated to edges of face
for (size_t i=0;i<numFaceCo;i++){
size_t edge = faceEdge[i];
size_t from = m_vSCVF[edge].From;
size_t to = m_vSCVF[edge].To;
MathVector<worldDim> normal = m_vSCVF[edge].Normal;
normal*=0.5;
size_t edgeCo[2];
size_t scvID[2];
for (size_t j=0;j<2;j++){
edgeCo[j] = m_rRefElem.id(1,edge,0,j);
// find corresponding face vertex (= corresponding scv index)
for (size_t k=0;k<numFaceCo;k++){
if (faceCo[k]==edgeCo[j]){
scvID[j] = m_numDofs+k;
break;
}
}
}
// look if edge has already been handled
if (m_numConstrainedDofs>0){
bool found=false;
for (size_t j=0;j<handledEdges.size();j++){
if (handledEdges[j].index==edge){
HandledEdge& hE=handledEdges[j];
found=true;
// set new from/to values
for (size_t k=0;k<2;k++){
if (hE.from){
m_vSCVF[hE.scvfIndex+k].To=scvID[k];
} else {
m_vSCVF[hE.scvfIndex+k].From=scvID[k];
}
}
// mark edge so associated scvf is not overwritten
faceEdge[i]=deleted;
break;
}
}
if (found==true) continue;
}
HandledEdge hEdge;
hEdge.index=edge;
hEdge.scvfIndex=m_numSCVF;
MathVector<worldDim> edgeMidGlob;
MathVector<dim> edgeMidLoc;
for (int d=0;d<worldDim;d++){
edgeMidGlob[d] = 0.5 * (vCornerCoords[edgeCo[0]][d] + vCornerCoords[edgeCo[1]][d]);
edgeMidLoc[d] = 0.5 * (m_rRefElem.corner(edgeCo[0])[d] + m_rRefElem.corner(edgeCo[1])[d]);
}
for (size_t j=0;j<2;j++){
hEdge.associatedSCV[j] = scvID[j];
if (from==face){
m_vSCVF[m_numSCVF].From = scvID[j];
m_vSCVF[m_numSCVF].To = to;
hEdge.from=true;
} else {
m_vSCVF[m_numSCVF].From = from;
m_vSCVF[m_numSCVF].To = scvID[j];
hEdge.from=false;
}
m_vSCVF[m_numSCVF].Normal = normal;
m_vSCVF[m_numSCVF].vGloPos[0] = vCornerCoords[edgeCo[j]];
m_vSCVF[m_numSCVF].vLocPos[0] = m_rRefElem.corner(edgeCo[j]);
m_vSCVF[m_numSCVF].vGloPos[1] = edgeMidGlob;
m_vSCVF[m_numSCVF].vLocPos[1] = edgeMidLoc;
m_vSCVF[m_numSCVF].vGloPos[2] = globalBary;
m_vSCVF[m_numSCVF].vLocPos[2] = localBary;
m_vSCVF[m_numSCVF].numSH = rTrialSpace.num_sh();
AveragePositions(m_vSCVF[m_numSCVF].localIP, m_vSCVF[m_numSCVF].vLocPos, m_vSCVF[m_numSCVF].numCo);
AveragePositions(m_vSCVF[m_numSCVF].globalIP, m_vSCVF[m_numSCVF].vGloPos, m_vSCVF[m_numSCVF].numCo);
rTrialSpace.shapes(&(m_vSCVF[m_numSCVF].vShape[0]), m_vSCVF[m_numSCVF].local_ip());
rTrialSpace.grads(&(m_vSCVF[m_numSCVF].vLocalGrad[0]), m_vSCVF[m_numSCVF].local_ip());
m_numSCVF++;
}
handledEdges.push_back(hEdge);
}
// scvfs inside the face
// insert remaining inner scvfs into positions of edge associated scvs
for (size_t j=0;j<numFaceCo;j++){
// replaces edge associated scvf
size_t ii = faceEdge[j];
if (ii==deleted){
ii = m_numSCVF;
m_numSCVF++;
}
if (numFaceCo==3){
// compute inner scvfs in triangular case
m_vSCVF[ii].From = m_numDofs+3;
m_vSCVF[ii].To = m_numDofs+j;
size_t ind = face;
if (j>0) ind = m_numSCV+j-1;
m_vSCVF[ii].vLocPos[0] = m_vSCV[ind].vLocPos[1];
m_vSCVF[ii].vLocPos[1] = m_vSCV[ind].vLocPos[2];
m_vSCVF[ii].vGloPos[0] = m_vSCV[ind].vGloPos[1];
m_vSCVF[ii].vGloPos[1] = m_vSCV[ind].vGloPos[2];
}else{
// compute inner scvfs in quadrilateral case
m_vSCVF[ii].To = m_numDofs+j;
m_vSCVF[ii].From = m_numDofs + ((j+1) % 4);
for (int d=0;d<worldDim;d++){
m_vSCVF[ii].vLocPos[0][d] = 0.5*( m_rRefElem.corner(faceCo[j])[d] + m_rRefElem.corner(faceCo[(j+1) % 4])[d] );
m_vSCVF[ii].vGloPos[0][d] = 0.5*( vCornerCoords[faceCo[j]][d] + vCornerCoords[faceCo[(j+1) % 4]][d] );
}
m_vSCVF[ii].vLocPos[1] = localMidpoint;
m_vSCVF[ii].vGloPos[1] = globalMidpoint;
}
m_vSCVF[ii].vLocPos[2] = localBary;
m_vSCVF[ii].vGloPos[2] = globalBary;
m_vSCVF[ii].numSH = rTrialSpace.num_sh();
ElementNormal<face_type0,worldDim>(m_vSCVF[ii].Normal,m_vSCVF[ii].vGloPos);
AveragePositions(m_vSCVF[ii].globalIP,m_vSCVF[ii].vGloPos,3);
AveragePositions(m_vSCVF[ii].localIP,m_vSCVF[ii].vLocPos,3);
rTrialSpace.shapes(&(m_vSCVF[ii].vShape[0]), m_vSCVF[ii].local_ip());
rTrialSpace.grads(&(m_vSCVF[ii].vLocalGrad[0]), m_vSCVF[ii].local_ip());
}
// insert new constrained dof object
m_vCD[m_numConstrainedDofs].i = face;
m_vCD[m_numConstrainedDofs].numConstrainingDofs = 4;
for (size_t i=0;i<4;i++){
m_vCD[m_numConstrainedDofs].cDofInd[i] = m_numDofs+i;
size_t ind=face;
if (i>0) ind = m_numSCV+i-1;
m_vCD[m_numConstrainedDofs].cDofWeights[i] = (number)m_vSCV[ind].Vol / faceVol;
}
m_numSCV+=3+keepOffset;
m_numDofs+=4;
m_numConstrainedDofs+=1;
m_roid = ROID_UNKNOWN;
}
}// end of hanging node check
//\todo compute with one virt. call
// compute jacobian for linear mapping
if(rMapping.is_linear())
{
MathMatrix<worldDim,dim> JtInv;
rMapping.jacobian_transposed_inverse(JtInv, m_vSCVF[0].local_ip());
const number detJ = rMapping.sqrt_gram_det(m_vSCVF[0].local_ip());
for(size_t i = 0; i < num_scvf(); ++i)
{
m_vSCVF[i].JtInv = JtInv;
m_vSCVF[i].detj = detJ;
}
for(size_t i = 0; i < num_scv(); ++i)
{
m_vSCV[i].JtInv = JtInv;
m_vSCV[i].detj = detJ;
}
}
// else compute jacobian for each integration point
else
{
for(size_t i = 0; i < num_scvf(); ++i)
{
rMapping.jacobian_transposed_inverse(m_vSCVF[i].JtInv, m_vSCVF[i].local_ip());
m_vSCVF[i].detj = rMapping.sqrt_gram_det(m_vSCVF[i].local_ip());
}
for(size_t i = 0; i < num_scv(); ++i)
{
rMapping.jacobian_transposed_inverse(m_vSCV[i].JtInv, m_vSCV[i].local_ip());
m_vSCV[i].detj = rMapping.sqrt_gram_det(m_vSCV[i].local_ip());
}
}
// compute global gradients
for(size_t i = 0; i < num_scvf(); ++i)
for(size_t sh = 0; sh < scvf(i).num_sh(); ++sh)
MatVecMult(m_vSCVF[i].vGlobalGrad[sh], m_vSCVF[i].JtInv, m_vSCVF[i].vLocalGrad[sh]);
for(size_t i = 0; i < num_scv(); ++i)
for(size_t sh = 0; sh < scv(i).num_sh(); ++sh)
MatVecMult(m_vSCV[i].vGlobalGrad[sh], m_vSCV[i].JtInv, m_vSCV[i].vLocalGrad[sh]);
// copy ip points in list (SCVF)
for(size_t i = 0; i < num_scvf(); ++i)
m_vGlobSCVF_IP[i] = scvf(i).global_ip();
// if no boundary subsets required, return
if(num_boundary_subsets() == 0 || ish == NULL) return;
else update_boundary_faces(pElem, vCornerCoords, ish);
}
void DimCRFVGeometry<TDim, TWorldDim>::
update(GridObject* pElem, const MathVector<worldDim>* vCornerCoords, const ISubsetHandler* ish)
{
// If already update for this element, do nothing
if(m_pElem == pElem) return; else m_pElem = pElem;
// refresh local data, if different roid given
if(m_roid != pElem->reference_object_id())
{
// remember new roid
m_roid = (ReferenceObjectID) pElem->reference_object_id();
// update local data
update_local_data();
}
// get reference element
try{
const DimReferenceElement<dim>& m_rRefElem
= ReferenceElementProvider::get<dim>(m_roid);
// compute barycenter coordinates
globalBary = vCornerCoords[0];
for (size_t j=1;j<m_rRefElem.num(0);j++){
globalBary+=vCornerCoords[j];
}
globalBary*=1./(number)m_rRefElem.num(0);
// compute global informations for scvf
for(size_t i = 0; i < num_scvf(); ++i)
{
for (size_t j=0;j<m_vSCVF[i].numCo-1;j++){
m_vSCVF[i].vGloPos[j]=vCornerCoords[m_rRefElem.id(dim-2,i,0,j)];
}
m_vSCVF[i].vGloPos[m_vSCVF[i].numCo-1]=globalBary;
AveragePositions(m_vSCVF[i].globalIP, m_vSCVF[i].vGloPos, m_vSCVF[i].numCo);
ElementNormal<face_type0,worldDim>(m_vSCVF[i].Normal,m_vSCVF[i].vGloPos);// face_type0 identical to scvf type
}
// compute size of scv
for(size_t i = 0; i < num_scv(); ++i)
{
// side nodes in reverse order to fulfill standard element order
for (int j=0;j<m_vSCV[i].numCorners-1;j++){
m_vSCV[i].vGloPos[m_vSCV[i].numCorners-2-j]=vCornerCoords[m_rRefElem.id(dim-1,i,0,j)];
}
AveragePositions(m_vGlobUnkCoords[i], m_vSCV[i].vGloPos, m_vSCV[i].numCorners-1);
m_vSCV[i].vGlobIP = m_vGlobUnkCoords[i];
m_vSCV[i].vGloPos[m_vSCV[i].numCorners-1]=globalBary;
// compute volume of scv and normal to associated element face
//CRSCVSizeAndNormal<dim>(m_vSCV[i].Vol,m_vSCV[i].Normal,m_vSCV[i].vGloPos,m_vSCV[i].numCorners);
if (m_vSCV[i].numCorners-1==dim){
m_vSCV[i].Vol = ElementSize<scv_type0,worldDim>(m_vSCV[i].vGloPos);
ElementNormal<face_type0, worldDim>(m_vSCV[i].Normal, m_vSCV[i].vGloPos);
} else { // m_vSCV[i].numCorners-2==dim , only possible in 3d (pyramid)
m_vSCV[i].Vol = ElementSize<scv_type1,worldDim>(m_vSCV[i].vGloPos);
ElementNormal<face_type1,worldDim>(m_vSCV[i].Normal, m_vSCV[i].vGloPos);
};
// nodes are in reverse order therefore reverse sign to get outward normal
m_vSCV[i].Normal*=-1;
}
// get reference mapping
DimReferenceMapping<dim, worldDim>& rMapping = ReferenceMappingProvider::get<dim, worldDim>(m_roid);
rMapping.update(vCornerCoords);
//\todo compute with on virt. call
// compute jacobian for linear mapping
if(rMapping.is_linear())
{
MathMatrix<worldDim,dim> JtInv;
rMapping.jacobian_transposed_inverse(JtInv, m_vSCVF[0].local_ip());
const number detJ = rMapping.sqrt_gram_det(m_vSCVF[0].local_ip());
for(size_t i = 0; i < num_scvf(); ++i)
{
m_vSCVF[i].JtInv = JtInv;
m_vSCVF[i].detj = detJ;
}
for(size_t i = 0; i < num_scv(); ++i)
{
m_vSCV[i].JtInv = JtInv;
m_vSCV[i].detj = detJ;
}
}
// else compute jacobian for each integration point
else
{
for(size_t i = 0; i < num_scvf(); ++i)
{
rMapping.jacobian_transposed_inverse(m_vSCVF[i].JtInv, m_vSCVF[i].local_ip());
m_vSCVF[i].detj = rMapping.sqrt_gram_det(m_vSCVF[i].local_ip());
}
for(size_t i = 0; i < num_scv(); ++i)
{
rMapping.jacobian_transposed_inverse(m_vSCV[i].JtInv, m_vSCV[i].local_ip());
m_vSCV[i].detj = rMapping.sqrt_gram_det(m_vSCV[i].local_ip());
}
}
// compute global gradients
for(size_t i = 0; i < num_scvf(); ++i)
for(size_t sh = 0; sh < scvf(i).num_sh(); ++sh)
MatVecMult(m_vSCVF[i].vGlobalGrad[sh], m_vSCVF[i].JtInv, m_vSCVF[i].vLocalGrad[sh]);
for(size_t i = 0; i < num_scv(); ++i)
for(size_t sh = 0; sh < scv(i).num_sh(); ++sh)
MatVecMult(m_vSCV[i].vGlobalGrad[sh], m_vSCV[i].JtInv, m_vSCV[i].vLocalGrad[sh]);
// copy ip points in list (SCVF)
for(size_t i = 0; i < num_scvf(); ++i)
m_vGlobSCVF_IP[i] = scvf(i).global_ip();
}
UG_CATCH_THROW("DimCRFVGeometry: update failed.");
// if no boundary subsets required, return
if(num_boundary_subsets() == 0 || ish == NULL) return;
else update_boundary_faces(pElem, vCornerCoords, ish);
}
void CRFVGeometry<TElem, TWorldDim>::
update(GridObject* elem, const MathVector<worldDim>* vCornerCoords, const ISubsetHandler* ish)
{
UG_ASSERT(dynamic_cast<TElem*>(elem) != NULL, "Wrong element type.");
TElem* pElem = static_cast<TElem*>(elem);
// If already update for this element, do nothing
if(m_pElem == pElem) return; else m_pElem = pElem;
// compute barycenter coordinates
globalBary = vCornerCoords[0];
m_vCo[0] = vCornerCoords[0];
for (size_t j=1;j<m_rRefElem.num(0);j++){
globalBary+=vCornerCoords[j];
m_vCo[j] = vCornerCoords[j];
}
globalBary*=1./(number)m_rRefElem.num(0);
// compute global informations for scvf
for(size_t i = 0; i < num_scvf(); ++i)
{
for (size_t j=0;j<m_vSCVF[i].numCo-1;j++){
m_vSCVF[i].vGloPos[j]=vCornerCoords[m_rRefElem.id(dim-2,i,0,j)];
}
m_vSCVF[i].vGloPos[m_vSCVF[i].numCo-1]=globalBary;
AveragePositions(m_vSCVF[i].globalIP, m_vSCVF[i].vGloPos, m_vSCVF[i].numCo);
ElementNormal<face_type0,worldDim>(m_vSCVF[i].Normal,m_vSCVF[i].vGloPos);// face_type0 identical to scvf type
}
// compute size of scv
for(size_t i = 0; i < num_scv(); ++i)
{
// side nodes in reverse order to fulfill standard element order
for (int j=0;j<m_vSCV[i].numCorners-1;j++){
m_vSCV[i].vGloPos[m_vSCV[i].numCorners-2-j]=vCornerCoords[m_rRefElem.id(dim-1,i,0,j)];
}
AveragePositions(m_vGlobUnkCoords[i], m_vSCV[i].vGloPos, m_vSCV[i].numCorners-1);
m_vSCV[i].vGlobIP = m_vGlobUnkCoords[i];
m_vSCV[i].vGloPos[m_vSCV[i].numCorners-1]=globalBary;
// compute volume of scv and normal to associated element face
//CRSCVSizeAndNormal<dim>(m_vSCV[i].Vol,m_vSCV[i].Normal,m_vSCV[i].vGloPos,m_vSCV[i].numCorners);
if (m_vSCV[i].numCorners-1==dim){
m_vSCV[i].Vol = ElementSize<scv_type0,worldDim>(m_vSCV[i].vGloPos);
ElementNormal<face_type0, worldDim>(m_vSCV[i].Normal, m_vSCV[i].vGloPos);
} else { // m_vSCV[i].numCorners-2==dim , only possible in 3d (pyramid)
m_vSCV[i].Vol = ElementSize<scv_type1,worldDim>(m_vSCV[i].vGloPos);
ElementNormal<face_type1, worldDim>(m_vSCV[i].Normal, m_vSCV[i].vGloPos);
};
// nodes are in reverse order therefore reverse sign to get outward normal
m_vSCV[i].Normal*=-1;
}
// Shapes and Derivatives
m_mapping.update(vCornerCoords);
// compute jacobian for linear mapping
if(ReferenceMapping<ref_elem_type, worldDim>::isLinear)
{
MathMatrix<worldDim,dim> JtInv;
m_mapping.jacobian_transposed_inverse(JtInv, m_vSCVF[0].local_ip());
const number detJ = m_mapping.sqrt_gram_det(m_vSCVF[0].local_ip());
for(size_t i = 0; i < num_scvf(); ++i)
{
m_vSCVF[i].JtInv = JtInv;
m_vSCVF[i].detj = detJ;
}
for(size_t i = 0; i < num_scv(); ++i)
{
m_vSCV[i].JtInv = JtInv;
m_vSCV[i].detj = detJ;
}
}
// else compute jacobian for each integration point
else
{
for(size_t i = 0; i < num_scvf(); ++i)
{
m_mapping.jacobian_transposed_inverse(m_vSCVF[i].JtInv, m_vSCVF[i].local_ip());
m_vSCVF[i].detj = m_mapping.sqrt_gram_det(m_vSCVF[i].local_ip());
}
for(size_t i = 0; i < num_scv(); ++i)
{
m_mapping.jacobian_transposed_inverse(m_vSCV[i].JtInv, m_vSCV[i].local_ip());
m_vSCV[i].detj = m_mapping.sqrt_gram_det(m_vSCV[i].local_ip());
}
}
// compute global gradients
for(size_t i = 0; i < num_scvf(); ++i)
for(size_t sh = 0; sh < scvf(i).num_sh(); ++sh)
MatVecMult(m_vSCVF[i].vGlobalGrad[sh], m_vSCVF[i].JtInv, m_vSCVF[i].vLocalGrad[sh]);
for(size_t i = 0; i < num_scv(); ++i)
for(size_t sh = 0; sh < scv(i).num_sh(); ++sh)
MatVecMult(m_vSCV[i].vGlobalGrad[sh], m_vSCV[i].JtInv, m_vSCV[i].vLocalGrad[sh]);
// copy ip points in list (SCVF)
for(size_t i = 0; i < num_scvf(); ++i)
m_vGlobSCVF_IP[i] = scvf(i).global_ip();
// if no boundary subsets required, return
if(num_boundary_subsets() == 0 || ish == NULL) return;
else update_boundary_faces(pElem, vCornerCoords, ish);
}
void Pince::in_state_func()
{
switch (state)
{
case RANGE_DEPART :
a1();
scv();
slr();
break;
case TAPE_VERTICAL :
a1();
scv();
slt();
break;
case INTERMEDIAIRE_SORTIE :
set_time_out(400, trigger_to_be);
a1();
slo();
scv();
break;
case HORIZ_VERT :
a1();
slo();
scn();
break;
case NOMINAL_VIDE :
set_time_out(500, trigger_to_be);
a0();
slo();
scn();
break;
case ACTIF_TORCHE :
a0();
slo();
scn();
break;
case PRISE_TORCHE :
Serial.println('# PRISE');
a0();
slf();
scn();
break;
case ACTIF_FEU :
a0();
slo();
scn();
break;
case PRISE_FEU :
Serial.println('# PRISE');
set_time_out(500, TIME_OUT);
a0();
slf();
scn();
break;
case WAIT_COOL_OK :
break;
case MONTE_COOL :
set_time_out(800, TIME_OUT);
a1();
slf();
scn();
break;
case MONTE_COOL2 :
a1();
slf();
scn();
break;
case RETOURNE_COOL_N :
set_time_out(500, TIME_OUT);
a1();
slf();
scr();
break;
case DESCEND_COOL_N :
a0();
slf();
scr();
break;
case POSE_COOL_N :
set_time_out(500, TIME_OUT);
a0();
slo();
scr();
break;
case INT1_COOL_N :
set_time_out(500, TIME_OUT);
a1();
slo();
scr();
break;
case INT2_COOL_N :
set_time_out(500, TIME_OUT);
a1();
slf();
scr();
break;
case INT3_COOL_N :
set_time_out(500, TIME_OUT);
a1();
slf();
scn();
break;
case INT_RANGE :
a1();
slo();
break;
case INT2_RANGE :
set_time_out(10, trigger_to_be);
a1();
slo();
break;
}
}
void Scene_Test::values()
{
Scene s(m_doc);
QVERIFY(s.values().size() == 0);
/* Value 3 to fixture 1's channel number 2 */
s.setValue(1, 2, 3);
QVERIFY(s.values().size() == 1);
QVERIFY(s.values().at(0).fxi == 1);
QVERIFY(s.values().at(0).channel == 2);
QVERIFY(s.values().at(0).value == 3);
/* Value 6 to fixture 4's channel number 5 */
SceneValue scv(4, 5, 6);
s.setValue(scv);
QVERIFY(s.values().size() == 2);
QVERIFY(s.values().at(0).fxi == 1);
QVERIFY(s.values().at(0).channel == 2);
QVERIFY(s.values().at(0).value == 3);
QVERIFY(s.values().at(1).fxi == 4);
QVERIFY(s.values().at(1).channel == 5);
QVERIFY(s.values().at(1).value == 6);
/* Replace previous value 3 with 15 for fixture 1's channel number 2 */
s.setValue(1, 2, 15);
QVERIFY(s.values().size() == 2);
QVERIFY(s.values().at(0).fxi == 1);
QVERIFY(s.values().at(0).channel == 2);
QVERIFY(s.values().at(0).value == 15);
QVERIFY(s.values().at(1).fxi == 4);
QVERIFY(s.values().at(1).channel == 5);
QVERIFY(s.values().at(1).value == 6);
QVERIFY(s.value(1, 2) == 15);
QVERIFY(s.value(3, 2) == 0); // No such channel
QVERIFY(s.value(4, 5) == 6);
/* No channel 5 for fixture 1 in the scene, unset shouldn't happen */
s.unsetValue(1, 5);
QVERIFY(s.values().size() == 2);
QVERIFY(s.values().at(0).fxi == 1);
QVERIFY(s.values().at(0).channel == 2);
QVERIFY(s.values().at(0).value == 15);
QVERIFY(s.values().at(1).fxi == 4);
QVERIFY(s.values().at(1).channel == 5);
QVERIFY(s.values().at(1).value == 6);
/* Remove fixture 1's channel 2 from the scene */
s.unsetValue(1, 2);
QVERIFY(s.values().size() == 1);
QVERIFY(s.values().at(0).fxi == 4);
QVERIFY(s.values().at(0).channel == 5);
QVERIFY(s.values().at(0).value == 6);
/* No fixture 1 anymore */
s.unsetValue(1, 2);
QVERIFY(s.values().size() == 1);
QVERIFY(s.values().at(0).fxi == 4);
QVERIFY(s.values().at(0).channel == 5);
QVERIFY(s.values().at(0).value == 6);
/* Remove fixture 4's channel 5 from the scene */
s.unsetValue(4, 5);
QVERIFY(s.values().size() == 0);
}
void Bras::in_state_func()
{
switch (state)
{
case RANGE_DEPART :
scr();
a0();
spb();
pf();
break;
case INT_RANGE :
//va bumper
scn();
a0();
spb();
pf();
break;
case INT2_RANGE :
set_time_out(400, trigger_to_be);
scn();
a0();
spb();
pf();
break;
case GO_ATTENTE :
scn();
a1();
spb();
pf();
break;
case ATTENTE_ACTIF :
scn();
a1();
spb();
pf();
break;
case DESCENTE_LAT :
scn();
a4();
spb();
pf();
break;
case DESCENTE_POMPE_LAT :
scn();
a4();
spb();
po();
break;
case PRISE_LAT :
scn();
a4();
spb();
po();
break;
case MONTE_VERT :
set_time_out(500, TIME_OUT);
scn();
a0();
spv();
po();
break;
case MONTE :
scn();
a0();
spb();
po();
break;
case RANGE_PRISE :
set_time_out(2000, TIME_OUT);
scl();
a0();
spb();
po();
break;
case LACHE :
set_time_out(300, TIME_OUT);
scl();
a0();
spb();
pf();
break;
case MONTE_ECH :
scn();
a3();
spb();
po();
break;
case MONTE_ECH_VERT :
sce();
a3();
spr();
po();
break;
case RETOURNE_ECH :
call_for_help();
sce();
a3();
spr();
po();
break;
case REPLACE_APRES_ECH :
set_time_out(300, TIME_OUT);
scn();
a3();
spb();
pf();
break;
case SEND_MINE :
scv();
a4();
spv();
pf();
break;
case SENDMASTER_PRET :
scv();
a4();
spv();
po();
break;
case PRISE_VERT :
scv();
a4();
spv();
po();
break;
case PRISE_COPAIN :
a2();
sce();
spb();
po();
break;
}
}
