ZZZ{

  classvar <cvMinLFO = -2.5,
  < cvMaxLFO = 2.5,
  < cvMinADSR = 0.0,
  < cvMaxADSR = 8.0,
  < cvMinTriggerGateClock = 0.0,
  < cvMaxTriggerGateClock = 5.0,
  < noteVoltageRangeMin = -5.0,
  < noteVoltageRangeMax = 7.0,
  < noteCpsRangeMin = 4.088,
  < noteCpsRangeMax = 16744.036;
  var <channels;

  *new{
    arg channels;
    ^super.newCopyArgs(channels);
  }

  *initClass{
    StartUp.add{
      // adding SynthDef for clock
      SynthDef(\ZZZClock, { |out = 0, freq = 2, iphase = 0, width = 0.1, mul= 1.0|
        Out.ar(out, LFPulse.ar(freq, iphase, width, mul));
      }).add;
      // adding SynthDef for constant notes
      SynthDef(\ZZZConstant, { |out = 0, mul= 0.0|
        Out.ar(
          out,
          Lag.ar(
            LFPulse.ar(
              500,
              0,
              1),
            0.1,
            mul
          )
        );
      }).add;
      //adding synth for percussive environments (trigger, gate)
      SynthDef(\ZZZPerc, { |out = 0, freq = 20000, amp = 0.0, attack = 0.001, release = 1, time = 1, curve = -4|
        var signal, envelope;
        envelope = EnvGen.kr(Env.perc(attack, release, amp, curve),  doneAction: 2);
        signal = SinOsc.ar(freq, 0, envelope);
        Out.ar(out, signal);
      }).add;
    }
  }

  /**
   * Calculates voltage for supplied amplitude.
   * Maximum: 10
   * Minimum: -10
   * @return voltage that corresponds to the amplitude supplied.
   */
  *amplitudevoltage{
    arg amplitude;
    var voltage = 0.0;
    if((amplitude == 0.0), {
      ^voltage;
    },{
      voltage = amplitude*10.0;
      if(voltage < -10.0, {
        ^(-10.0);
      });
      if(voltage > 10.0, {
        ^(10.0);
      });
      ^voltage;
    });
  }

  /**
   * Calculates amplitude for supplied voltage.
   * Maximum: 1.0
   * Minimum: -1.0
   * @return amplitude needed to achieve the voltage supplied.
   */
  *voltageamplitude{
    arg voltage;
    var amplitude = 0.0;
    if((voltage == 0.0), {
      ^amplitude;
    },{
      amplitude = voltage/10.0;
      if(amplitude < -1.0, {
        ^(-1.0);
      });
      if(amplitude > 1.0, {
        ^(1.0);
      });
      ^amplitude;
    });
  }

  /**
   * Calculates voltage for supplied cycles per second.
   * @return voltage for corresponding cycles per second
   */
  *cpsvoltage{
    arg cps;
    if(cps < noteCpsRangeMin, {
      cps = noteCpsRangeMin;
    });
    if(cps > noteCpsRangeMax, {
      cps = noteCpsRangeMax;
    });
    ^cps.explin(noteCpsRangeMin, noteCpsRangeMax, noteVoltageRangeMin, noteVoltageRangeMax);
  }

  /**
   * Calculates cycles per second for supplied voltage.
   * @return cycles per second for corresponding voltage
   */
  *voltagecps{
    arg voltage;
    if(voltage < noteVoltageRangeMin, {
      voltage = noteVoltageRangeMin;
    });
    if(voltage > noteVoltageRangeMax, {
      voltage = noteVoltageRangeMax;
    });
    ^voltage.linexp(noteVoltageRangeMin, noteVoltageRangeMax, noteCpsRangeMin, noteCpsRangeMax);
  }

  /**
   * Calculates amplitude for supplied frequency.
   * @return amplitude for corresponding frequency
   */
  *cpsamp{
    arg cps;
    ^this.voltageamplitude(this.cpsvoltage(cps));
  }

  /**
   * Calculates frequency for supplied amplitude.
   * Wraps call to ampToVAC -> vacToHz
   * @return frequency for corresponding amplitude
   */
  *ampcps{
    arg amplitude;
    ^this.voltagecps(this.amplitudevoltage(amplitude));
  }
}