Sequence.cpp

Go to the documentation of this file.

//
// Class Sequence
//   The SEQUENCE definition.
//   A Sequence contains a CLASSIC TBeamline<SequenceMember> which represents
//   the sequence of elements in the line and their positions.  The sequence
//   definition is parsed in collaboration with a SequenceParser.
//
// Copyright (c) 200x - 2020, Paul Scherrer Institut, Villigen PSI, Switzerland
// All rights reserved
//
// This file is part of OPAL.
//
// OPAL is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//
#include "Lines/Sequence.h"
#include "AbstractObjects/Attribute.h"
#include "AbstractObjects/OpalData.h"
#include "Attributes/Attributes.h"
#include "BeamlineCore/DriftRep.h"
#include "Beamlines/Beamline.h"
#include "Elements/OpalDrift.h"
 
#include "Lines/Replacer.h"
#include "Lines/SequenceParser.h"
#include "Lines/SequenceTemplate.h"
#include "Utilities/OpalException.h"
#include "Utilities/Options.h"
 
#include <cmath>
#include <iostream>
#include <sstream>
#include <vector>
 
// The attributes of class Sequence.
namespace {
    enum {
        TYPE,     // The design type.
        LENGTH,   // The total sequence length.
        REFER,    // The reference position for members.
        REFPOS,   // The reference position for the sequence.
        SIZE
    };
}
 
 
Sequence::Sequence():
    BeamSequence(SIZE, "SEQUENCE",
                 "The \"SEQUENCE\" statement initiates parsing of an "
                 "element sequence.\n"
                 "\t<label>: SEQUENCE,L=<length>,REFER=<reference>\n"
                 "\t\t...\n"
                 "\t\t<object>: <class>,AT=<real>{,<attribute>=<value>}\n"
                 "\t\t<object>: <class>,DRIFT=<real>{,<attribute>=<value>}\n"
                 "\t\t...\n"
                 "\tEND;") {
    itsAttr[TYPE] = Attributes::makeString
                    ("TYPE", "The design type");
    itsAttr[LENGTH] = Attributes::makeReal
                      ("L", "Total length of sequence in m");
 
    itsAttr[REFER] = Attributes::makeString
                     ("REFER",
                      "Reference position for members:\n"
                      "\tENTRY | EXIT | CENTRE (default is CENTRE)", "CENTRE");
    itsAttr[REFPOS] = Attributes::makeString
                      ("REFPOS",
                       "Element giving reference position for this sequence"
                       "\t(if given, this position is used instead of the centre, when the"
                       "\tsequence is nested in another sequence with \"REFER=CENTRE\")");
 
    setElement(new TLine("SEQUENCE"));
 
    registerOwnership(AttributeHandler::STATEMENT);
}
 
 
Sequence::Sequence(const std::string &name, Sequence *parent):
    BeamSequence(name, parent)
    // Do not copy parent's line, it will be filled in at parse time,
    // In case of a clone within a sequence, it is filled by the method
    // SequenceParser::parseMember().
{
    setElement(new TLine(name));
}
 
 
Sequence::~Sequence()
{}
 
 
Sequence *Sequence::clone(const std::string &name) {
    return new Sequence(name, this);
}
 
 
Sequence *Sequence::copy(const std::string &name) {
    TLine *oldLine = fetchLine();
    TLine *newLine = new TLine(name);
 
    for(TLine::iterator i = oldLine->begin(); i != oldLine->end(); ++i) {
        SequenceMember member(*i);
 
        if(i->itsType == SequenceMember::GENERATED) {
            member.setElement(member.getElement()->clone());
        } else {
            member.setElement(member.getElement()->copyStructure());
        }
 
        newLine->push_back(member);
    }
 
    Sequence *newSeq = dynamic_cast<Sequence *>(clone(name));
    newSeq->storeLine(*newLine);
    return newSeq;
}
 
Sequence::TLine::iterator
Sequence::findNamedPosition(TLine &line, const std::string &name) const {
    TLine::iterator first = line.begin();
    TLine::iterator last  = line.end();
 
    for(TLine::iterator iter = first; iter != last; ++iter) {
        if(iter->itsType != SequenceMember::GENERATED) {
            if(iter->getElement()->getName() == name) {
                TLine::iterator test = iter;
 
                while(++test != line.end()) {
                    if(test->getElement()->getName() == name) {
                        throw OpalException("Sequence::findNamedPosition()", "Element \"" +
                                            name + "\" is not unique in sequence.");
                    }
                }
 
                return iter;
            }
        }
    }
 
    throw OpalException("Sequence::findNamedPosition()",
                        "Element \"" + name + "\" not found in sequence.");
}
 
 
double Sequence::getLength() const {
    return Attributes::getReal(itsAttr[LENGTH]);
}
 
 
double Sequence::getEntrance(ReferenceType ref) const {
    if(itsRefPoint.empty()) {
        return Element::getEntrance(ref);
    } else {
        TLine *line = fetchLine();
        TLine::iterator iter = findNamedPosition(*line, itsRefPoint);
        return (- iter->itsPosition);
    }
}
 
 
double Sequence::getExit(ReferenceType ref) const {
    if(itsRefPoint.empty()) {
        return Element::getExit(ref);
    } else {
        TLine *line = fetchLine();
        TLine::iterator iter = findNamedPosition(*line, itsRefPoint);
        return (getLength() - iter->itsPosition);
    }
}
 
 
Sequence::ReferenceType Sequence::getReference() const {
    std::string ref = Attributes::getString(itsAttr[REFER]);
    ReferenceType code = IS_CENTRE;
 
    if(ref == "ENTRY") {
        code = IS_ENTRY;
    } else if(ref == "EXIT") {
        code = IS_EXIT;
    }
 
    return code;
}
 
 
Object *Sequence::makeTemplate
(const std::string &name, TokenStream &is, Statement &statement) {
    SequenceTemplate *macro = new SequenceTemplate(name, this);
 
    try {
        macro->parseTemplate(is, statement);
        return macro;
    } catch(...) {
        delete macro;
        macro = 0;
        throw;
    }
}
 
 
void Sequence::parse(Statement &statement) {
    // Look for "REFER" and "L" attributes.
    Object::parse(statement);
 
    // Set up to parse members.
    SequenceParser parser(this);
    parser.run();
    if(itsAttr[REFPOS]) itsRefPoint = Attributes::getString(itsAttr[REFPOS]);
}
 
 
 
void Sequence::print(std::ostream &os) const {
    TLine *line = fetchLine();
    std::streamsize old_prec = os.precision(12);
 
    if(isShared()) os << "SHARED ";
    os << getOpalName() << ":SEQUENCE";
 
    for(const Attribute& i : itsAttr) {
        if(i) {
            os << ',' << i.getName()
               << (i.isExpression() ? ":=" : "=") << i;
        }
    }
 
    os << ";" << std::endl;
 
    for(TLine::const_iterator iter = line->begin();
        iter != line->end(); ++iter) {
        const SequenceMember &member = *iter;
 
        if(member.itsType != SequenceMember::GENERATED) {
            const std::string &name = member.getElement()->getName();
            if(name[0] != '#') {
                // Name of current element.
                os << "  ";
                if(member.getReflectionFlag()) os << '-';
                os << name;
 
                // Position of current element.
                os << ",AT=" << member.itsPosition;
                os << ';' << std::endl;
            }
        }
    }
 
    os << "ENDSEQUENCE;" << std::endl;
 
    os.precision(old_prec);
}
 
 
void Sequence::replace(Object *oldObject, Object *newObject) {
    Element *oldElement = dynamic_cast<Element *>(oldObject);
    Element *newElement = dynamic_cast<Element *>(newObject);
 
    if(oldElement != 0  &&  newElement != 0) {
        Replacer rep(*fetchLine(),
                     oldElement->getOpalName(),
                     newElement->getElement());
        rep.execute();
    }
}
 
 
void Sequence::update() {
    TLine *line = fetchLine();
    if(! line->empty()) updateList(this, line);
}
 
 
Sequence::TLine *Sequence::fetchLine() const {
    return dynamic_cast<TLine *>(getElement());
}
 
 
void Sequence::storeLine(TLine &newLine) {
    // Remove any old line and assign new one.
    TLine *line = fetchLine();
    line->erase(line->begin(), line->end());
    line->swap(newLine);
 
    // Store the reference code.
    itsCode = getReference();
 
    // Clear all occurrence counts.
    OpalData::getInstance()->apply(OpalData::ClearReference());
 
    // Set occurrence counts.
    for(TLine::iterator i = line->begin(); i != line->end(); ++i) {
        if(i->itsType != SequenceMember::GENERATED) {
            const std::string &name = i->getElement()->getName();
            Element *elem = Element::find(name);
            // ada 4.5 2000 to speed up matching, add a pointer to
            // opal elements in order to avoid serching the opal elements
            i->OpalElement = elem;
            i->setCounter(elem->increment());
        }
    }
 
    // Fill in the drift spaces.
    // update();
}
 
 
void Sequence::addEndMarkers(TLine &line) const {
    SequenceMember member;
    member.setElement(Element::find("#S")->getElement());
    member.itsPosition = 0.0;
    member.itsFlag = SequenceMember::ABSOLUTE;
    member.itsType = SequenceMember::GLOBAL;
    line.push_front(member);
    member.setElement(Element::find("#E")->getElement());
    member.itsPosition = getLength();
    line.push_back(member);
}
 
 
double Sequence::findDriftLength(TLine::iterator drift) const {
    // It is assumed that the elements preceding and following the drift exist.
    TLine::iterator prev(drift);
    --prev;
    const std::string prev_name = prev->getElement()->getName();
 
    // ada 4.5 2000 to speed up matching, add a pointer to
    // opal elements in order to avoid serching the opal elements
    // Element *prev_elem = Element::find(prev_name);
    Pointer<Element> prev_elem = prev->OpalElement;
    double prev_exit = prev->itsPosition + prev_elem->getExit(itsCode);
 
    TLine::iterator next(drift);
    ++next;
    const std::string next_name = next->getElement()->getName();
 
    // ada 4.5 2000 to speed up matching, add a pointer to
    // opal elements in order to avoid serching the opal elements
    // Element *next_elem = Element::find(next_name);
    Pointer<Element> next_elem = next->OpalElement;
    double next_entry = next->itsPosition + next_elem->getEntrance(itsCode);
 
    double driftLength = next_entry - prev_exit;
 
    static double tolerance = 1.0e-8;
    if(std::abs(driftLength) < tolerance) {
        driftLength = 0.0;
    } else if(driftLength < 0.0) {
        driftLength = 0.0;
        std::ostringstream os;
        os << "Inconsistent positions in sequence \"" << getOpalName() + "\";\n"
           << "previous element:  \"" << prev_name + "\" at = "
           << prev->itsPosition << ",\n"
           << "following element: \"" << next_name + "\" at = "
           << next->itsPosition << "." << std::ends;
        throw OpalException("Sequence::findDriftLength()", os.str());
        // ada 15-6-2000 move driftLength = 0.0; bevore throw
    }
 
    return driftLength;
}
 
 
void Sequence::insertDrifts(Sequence::TLine &line) {
    TLine::iterator i = line.begin();
    while(true) {
        ++i;
        if(i == line.end()) break;
        SequenceMember member;
        DriftRep *drift = new DriftRep();
        drift->setName("[DRIFT]");
        member.setElement(drift);
        member.itsType = SequenceMember::GENERATED;
        line.insert(i, member);
    }
}
 
 
void Sequence::updateList(Sequence *seq, TLine *line) {
    TLine::iterator iter = line->begin();
    TLine::iterator last = line->end();
 
    while(true) {
        // Recursive call for nested beam non-shared sequence.
        if(iter == last) break;
        ElementBase *base = iter->getElement();
        if(! base->isSharable()) {
            TLine *sub_line = dynamic_cast<TLine *>(base);
            if(sub_line != 0) {
                const std::string &sub_name = sub_line->getName();
                Sequence *sub_seq = dynamic_cast<Sequence *>(OpalData::getInstance()->find(sub_name));
                updateList(sub_seq, sub_line);
            }
        }
        ++iter;
 
        // Fill in drift length.
        if(iter == last) break;
        double driftLength = seq->findDriftLength(iter);
        iter->setLength(driftLength);
        ++iter;
    }
}