Sequence.h

Go to the documentation of this file.

//
// Class Sequence
//   The SEQUENCE definition.
//   A Sequence contains an OPALX 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/>.
//
#ifndef OPAL_Sequence_HH
#define OPAL_Sequence_HH
 
#include <list>
#include <memory>
#include "AbsBeamline/ElementBase.h"
#include "AbstractObjects/BeamSequence.h"
#include "Beamlines/TBeamline.h"
#include "Lines/SequenceMember.h"
 
class TokenStream;
 
class Sequence : public BeamSequence {
    friend class Edit;
    friend class SequenceParser;
    friend class SequenceTemplate;
 
public:
    typedef TBeamline<SequenceMember> TLine;
 
    Sequence();
 
    virtual ~Sequence();
 
    // The new object is an empty sequence, it will be filled in by the parser.
    virtual Sequence* clone(const std::string& name);
 
    virtual Sequence* copy(const std::string& name);
 
    virtual double getLength() const;
 
    virtual double getEntrance(ReferenceType) const;
 
    virtual double getExit(ReferenceType) const;
 
    //  "ENTRY", "CENTRE", or "EXIT".
    ReferenceType getReference() const;
 
    //  Arguments:
    //  [ol]
    //  [li] Name to be given to the template.
    //  [li] Token stream to be read for the sequence line.
    //  [li] Statement to be read for the arguments.
    //  [/ol]
    virtual Object* makeTemplate(const std::string&, TokenStream&, Statement&);
 
    virtual void parse(Statement&);
 
    virtual void print(std::ostream&) const;
 
    virtual void replace(Object* oldObject, Object* newObject);
 
    //  Recompute drift lengths.
    virtual void update();
 
    //  The result it the ideal line.
    virtual TLine* fetchLine() const;
 
    //  Assign to the underlying ideal line and re-insert the drifts.
    void storeLine(TLine& line);
 
private:
    // Not implemented.
    Sequence(const Sequence&);
    void operator=(const Sequence&);
 
    // Clone constructor.
    Sequence(const std::string& name, Sequence* parent);
 
    // Add the top-level begin and end markers.
    void addEndMarkers(TLine& line) const;
 
    // Compute drift length for a generated drift.
    double findDriftLength(TLine::iterator drift) const;
 
    // Find named position in sequence line.
    TLine::iterator findNamedPosition(TLine&, const std::string&) const;
 
    // Insert the top-level drift spaces.
    void insertDrifts(TLine& line);
 
    //  Recompute drift lengths for a given sequence or sub-sequence.
    static void updateList(Sequence*, TLine*);
 
    // The reference code.
    ReferenceType itsCode;
 
    // The reference point.
    std::string itsRefPoint;
};
 
#endif  // OPAL_Sequence_HH