WIP, add chn_map

kwang428 · yuyichao · commit 62b9e3434f9f · 2026-04-18T17:13:32.000-04:00
diff --git a/lib/nacs-seq/manager.cpp b/lib/nacs-seq/manager.cpp
@@ -275,6 +275,215 @@ NACS_EXPORT() uint32_t Manager::ExpSeq::refresh_device_restart(const char *dname
     return uint32_t(-1);
 }
 
+NACS_EXPORT() Manager::ExpSeq::ChnOutput* Manager::ExpSeq::get_nominal_output(uint64_t pts_per_ramp, size_t *out_sz)
+{
+    // pts_per_ramp includes the first and last point, so it must be at least 2. It will be set to 2 if not the case.
+    // Temporary insofar as keeping the start value, and pulses for this channel. 
+    struct FilledPulse {
+        FilledPulse(uint32_t id, int64_t time, int64_t len, double (*ramp_func)(double, void*),
+                    double endvalue, bool cond)
+            : id(id), time(time), len(len), ramp_func(ramp_func),
+              endvalue(endvalue), cond(cond)
+        {
+            // empty
+        }
+        uint32_t id;
+
+        int64_t time;
+        int64_t len; // 0 for a set pulse and nonzero for a ramp.
+        double (*ramp_func)(double, void*);
+
+        double endvalue;
+        bool cond;
+    };
+    struct TempChnOutput {
+        TempChnOutput(std::string name, double start_val)
+            : m_name(name),
+              m_start_val(start_val)
+            {
+                //
+            }
+        std::string m_name;
+        double m_start_val;
+        std::vector<FilledPulse> m_pulses;
+        std::vector<int64_t> times;
+        std::vector<double> values;
+        std::vector<uint32_t> pulse_ids;
+    };
+    uint32_t nchannels = host_seq.nchannels;
+    auto seq_idx = host_seq.cur_seq_idx();
+    if (nchannels == 0 || seq_idx == uint32_t(-1)) {
+        *out_sz = 0;
+        return nullptr;
+    }
+
+    std::map<uint32_t,TempChnOutput> temp_chn_outputs;
+    std::vector<Manager::ExpSeq::ChnOutput> outputs;
+
+    // Initialize the temp output for each channel.
+    for (auto &[name, chn_id]: m_chn_map) {
+        std::string chn_name = name;
+        double start_val = host_seq.start_values[chn_id - 1].f64;
+        printf("Channel %s (ID: %d) start value: %f\n", chn_name.c_str(), chn_id, start_val);
+        temp_chn_outputs.try_emplace(chn_id - 1, chn_name, start_val);
+    }
+    // Collect the pulses along with their filled values for each channel.
+    auto &bseq = host_seq.seqs[seq_idx];
+    // Keep track of the max time
+    int64_t max_time = 0;
+    for (auto &pulse: bseq.pulses) {
+        if (pulse.is_measure())
+            continue;
+        int64_t time = host_seq.get_time(pulse.time);
+        // Using this call double get_value(uint32_t i, uint32_t seq_idx) const
+        int64_t len = pulse.len == uint32_t(-1) ? 0 : round<int64_t>(host_seq.get_value(pulse.len, seq_idx));
+        double endvalue = host_seq.get_value(pulse.endvalue, seq_idx);
+        bool cond = pulse.cond == uint32_t(-1) ? true : (bool) host_seq.get_value(pulse.cond, seq_idx);
+        printf("Pulse ID: %d, Channel: %d, Time: %ld, Length: %ld, End Value: %f, Condition: %d\n",
+               pulse.id, pulse.chn, time, len, endvalue, cond);
+        auto it = temp_chn_outputs.find(pulse.chn - 1);
+        if (it == temp_chn_outputs.end()) {
+            throw std::runtime_error("Missing channel ID");
+        } else {
+            auto &temp_output = it->second;
+            temp_output.m_pulses.emplace_back(pulse.id, time, len, pulse.ramp_func, endvalue, cond);
+        }
+    }
+    // With all the pulses, we now build our output.
+    for (auto &[chn_id, temp_output]: temp_chn_outputs) {
+        // First we sort them.
+        auto &pulses = temp_output.m_pulses;
+        std::sort(pulses.begin(), pulses.end(), [] (auto &p1, auto &p2) {
+            if (p1.time < p2.time)
+                return true;
+            if (p1.time > p2.time)
+                return false;
+            return p1.id < p2.id;
+        });
+        // Start building the output with the start value
+        auto &times = temp_output.times;
+        auto &values = temp_output.values;
+        auto &pulse_ids = temp_output.pulse_ids;
+        times.push_back(0);
+        values.push_back(temp_output.m_start_val);
+        pulse_ids.push_back(uint32_t(-1)); // the start value is not identified with any particular pulse.
+        auto npulses = pulses.size();
+        for (uint32_t i = 0; i < npulses;) {
+            auto &pulse = pulses[i];
+            // This check should rarely execute, except if the first pulse is disabled.
+            if (!pulse.cond) {
+                // Skip disabled pulse
+                i++;
+                continue;
+            }
+            // Find next pulse which is important for ensuring that this set pulse will take place and
+            // determines the end time for a potentially interrupted ramp.
+            bool found = false;
+            FilledPulse *next_pulse_ptr = nullptr;
+            i++; // Move to the next pulse
+            while (!found) {
+                if (i >= npulses) {
+                    found = true;
+                }
+                else {
+                    if (pulses[i].cond) {
+                        next_pulse_ptr = &pulses[i];
+                        found = true;
+                    } else {
+                        // Skip disabled pulse
+                        i++;
+                    }
+                }
+            }
+            // Below here, i does not need to be advanced!
+            if (pulse.len == 0) {
+                // Set pulse
+                // Only valid if next pulse is not at the same time.
+                if (next_pulse_ptr && (next_pulse_ptr->time <= pulse.time)) {
+                    // Skip current pulse
+                    continue;
+                }
+                // If previous point is not at the current time, then add a point with the previous value.
+                if (times.back() != pulse.time) {
+                    times.push_back(pulse.time);
+                    values.push_back(values.back()); // Use the last value.
+                    pulse_ids.push_back(pulse_ids.back()); // No pulse ID for this point.
+                }
+                times.push_back(pulse.time);
+                values.push_back(pulse.endvalue);
+                pulse_ids.push_back(pulse.id);
+            } else {
+                // Ramp pulse
+                // Get end time by looking for the next pulse.
+                int64_t end_time;
+                if (next_pulse_ptr) {
+                    end_time = min(next_pulse_ptr->time, pulse.time + pulse.len);
+                }
+                else {
+                    end_time = pulse.time + pulse.len;
+                }
+                int64_t ramp_time = end_time - pulse.time;
+                assert(ramp_time >= 0);
+                if (ramp_time == 0) {
+                    // If the ramp time is 0, we let the next pulse dictate what happens.
+                    continue;
+                }
+                // If previous point is not at the current time, then add a point with the previous value.
+                if (times.back() != pulse.time) {
+                    times.push_back(pulse.time);
+                    values.push_back(values.back()); // Use the last value.
+                    pulse_ids.push_back(pulse_ids.back()); // No pulse ID for this point.
+                }
+                // Calculate the ramp with at least pts_per_ramp points.
+                uint64_t npts = max(2, min((uint64_t) ramp_time, pts_per_ramp));
+                for (uint64_t j = 0; j < npts; j++) {
+                    int64_t this_pt = round<int64_t>(j * ramp_time / (npts - 1));
+                    int64_t this_time = pulse.time + this_pt;
+                    times.push_back(this_time);
+                    values.push_back(pulse.ramp_func(this_pt, host_seq.values.data()));
+                    pulse_ids.push_back(pulse.id);
+                }
+            }
+        }
+        int64_t last_time = times.back();
+        if (last_time > max_time) {
+            max_time = last_time;
+        }
+    }
+
+    // Now, we have built our output for each channel, we need to allocate some memory to pass it onto the next user.
+    // We also append an extra point if not already at the max time
+    for (auto &[chn_id, temp_output]: temp_chn_outputs) {
+        auto &times = temp_output.times;
+        auto &values = temp_output.values;
+        auto &pulse_ids = temp_output.pulse_ids;
+        // If the last time is not the max time, we add an extra point with the last value.
+        if (times.back() != max_time) {
+            times.push_back(max_time);
+            values.push_back(values.back());
+            pulse_ids.push_back(pulse_ids.back());
+        }
+        auto names_ptr = (char*) malloc(temp_output.m_name.size() + 1);
+        auto times_ptr = (int64_t*) malloc(times.size() * sizeof(int64_t));
+        auto values_ptr = (double*) malloc(values.size() * sizeof(double));
+        auto pulse_ids_ptr = (uint32_t*) malloc(pulse_ids.size() * sizeof(uint32_t));
+        size_t out_pts = times.size(); // All sizes should be the same.
+        memcpy(names_ptr, temp_output.m_name.data(), temp_output.m_name.size() + 1);
+        memcpy(times_ptr, times.data(), out_pts * sizeof(int64_t));
+        memcpy(values_ptr, values.data(), out_pts * sizeof(double));
+        memcpy(pulse_ids_ptr, pulse_ids.data(), out_pts * sizeof(uint32_t));
+        // Create the output object
+        outputs.emplace_back(names_ptr, temp_output.m_name.size() + 1, times_ptr, values_ptr, pulse_ids_ptr, out_pts);
+    }
+
+    // Last allocation of memory for the outputs array, which carries a bunch of addresses.
+    auto outputs_ptr = (Manager::ExpSeq::ChnOutput*) malloc(outputs.size() * sizeof(Manager::ExpSeq::ChnOutput));
+    memcpy(outputs_ptr, outputs.data(), outputs.size() * sizeof(Manager::ExpSeq::ChnOutput));
+    *out_sz = outputs.size();
+
+    return outputs_ptr;
+}
+
 NACS_EXPORT_ Manager::Manager()
 {
 }
@@ -319,6 +528,7 @@ NACS_EXPORT() Manager::ExpSeq *Manager::create_sequence(const uint8_t *data, siz
             if (dev->check_noramp(chn_id, chn_name)) {
                 builder.noramp_chns.push_back(chn_id);
             }
+            expseq->m_chn_map.emplace(name, chn_id);
         }
         add_debug("Building sequence\n");
         builder.buildseq();
@@ -883,4 +1093,14 @@ NACS_EXPORT() uint32_t nacs_seq_manager_expseq_refresh_device_restart(Manager::E
     }, uint32_t(-1));
 }
 
+NACS_EXPORT() Manager::ExpSeq::ChnOutput*
+nacs_seq_manager_expseq_get_nominal_output(
+    Manager::ExpSeq *expseq, uint64_t pts_per_ramp, size_t *sz)
+{
+    return expseq->mgr().call_guarded([&] () -> Manager::ExpSeq::ChnOutput* {
+            return expseq->get_nominal_output(pts_per_ramp, sz);
+        }, nullptr);
+}
+
+
 }
diff --git a/lib/nacs-seq/manager.h b/lib/nacs-seq/manager.h
@@ -77,6 +77,20 @@ class Manager {
 
     class ExpSeq {
     public:
+        struct ChnOutput {
+            ChnOutput(char *name, size_t name_sz, int64_t *times, double *values, uint32_t *pulse_ids, size_t npts)
+            : name(name), name_sz(name_sz), times(times), values(values), pulse_ids(pulse_ids), npts(npts)
+            {
+                //
+            }
+
+            char *name;
+            size_t name_sz;
+            int64_t *times;
+            double *values;
+            uint32_t *pulse_ids;
+            size_t npts;
+        };
         ExpSeq(Manager *mgr, CGContext *cgctx);
         ~ExpSeq();
 
@@ -138,8 +152,10 @@ class Manager {
             std::vector<uint8_t> seq_opt;
         };
         std::unique_ptr<Dump> dump;
+        std::map<std::string,uint32_t> m_chn_map; // Tracks the mapping from channel name to index.
 
         uint32_t refresh_device_restart(const char *dname);
+        ChnOutput* get_nominal_output(uint64_t pts_per_ramp, size_t *out_sz);
 
     private:
         template<typename Str>
