#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <iomanip>
#include <limits>
#include <math.h>
#include <TArc.h>
#include <TArrow.h>
#include <TBox.h>
#include <TBrowser.h>
#include <TCanvas.h>
#include <TCondition.h>
#include <TDatime.h>
#include <TDirectory.h>
#include <TEllipse.h>
#include <TGraphErrors.h>
#include <TGButton.h>
#include <TGButtonGroup.h>
#include <TGClient.h>
#include <TGComboBox.h>
#include <TGProgressBar.h>
#include <TGLabel.h>
#include <TGTextEntry.h>
#include <TGFrame.h>
#include <TGraph.h>
#include <TGraphErrors.h>
#include <TF1.h>
#include <TFile.h>
#include <TH1D.h>
#include <TH2D.h>
#include <TLatex.h>
#include <TLeaf.h>
#include <TLine.h>
#include "TMath.h"
#include <TObjectTable.h>
#include <TPaveText.h>
#include <TPolyLine.h>
#include <TProfile.h>
#include <TRandom.h>
#include <TRootEmbeddedCanvas.h>
#include <TStyle.h>
#include <TTree.h>
#include "TSystem.h"
#include <TVectorD.h>
#include <TDatime.h>
#include <sys/types.h>
#include <time.h>
#include <TROOT.h>
#include <TError.h>
#include "TVirtualFFT.h"

#include  <cstring>

struct logic_unit {
private:
  char name[200];
  char type[200];
  char IDname[20];
  char text[20];
  std::string name1;//
  std::string type1;//

  int logic_type;
  int ID;

  double X;
  double Y;

  int ninput;
  int iHalo;
  int oHalo;
  int nout;
  int crate;
  int station; // station in crate
  int unit;    // unit in station
  int switch_set; // mode set where availabe
//
  double tOut;
  double scale;
  double Xsize;
  double Ysize;
  double yin0[40];
  double xin0[40];
  double xin1[40];
  bool   intyp[40];
  double yout0[40];
  double xout0[40];
  double xout1[40];
  bool   outtyp[40];

  std::vector<std::string> in_names;
  std::vector<std::string> out_names;

  TLine*  myLine;
  TLatex* myLatex;
  TArc*   myArc;
  TBox*   myBox;

public:
//===========================================================
void Set_Unit(std::string ct, int id, int cr, int p, int u, int set, 
              double x, double y, double s, std::string nm) {
// logic_type = 0  coinsidence 4 inputs with pins
// logic_type = 1  logical FAN IN - FAN OUT
// logic_type = 2  analog  FAN IN - FAN OUT

  myLine  = new TLine();
  myLatex = new TLatex();
  myArc   = new TArc();
  myBox   = new TBox();

  X=x;
  Y=y;
  scale=s;

  ID=id;
  sprintf(IDname, "%d", ID);
  crate=cr;
  station=p;
  unit=u;

  switch_set=set;

  name1=nm;
  type1=ct;

  strcpy(name, name1.c_str());
  strcpy(type, type1.c_str());

  if (type1=="LeCroy 365AL") { // 4-fold logic unit
    logic_type=0;
    Xsize=10.;
    Ysize=20.;
    ninput=5;
    nout=6;
    for (int i=0; i<4; i++) {
      intyp[i] =true;
      in_names.push_back(" ");
    }
    intyp[4] =false;
    in_names.push_back("Veto");
    for (int i=0; i<4;      i++) {
      outtyp[i]=true;
      out_names.push_back(" ");
    }
    for (int i=4; i<6;      i++) {
      outtyp[i]=false;
      out_names.push_back(" ");
    }

  } else if (type1=="LeCroy 825") { // 5-fold Risetime compensated discr.
    logic_type=1;
    Xsize=10.;
    Ysize=15.;
    ninput=1;
    nout=3;
    for (int i=0; i<ninput; i++) {
      intyp[i] =true;
      in_names.push_back(" ");
    }
    for (int i=0; i<2;      i++) {
      outtyp[i]=true;
      out_names.push_back(" ");
    }
    outtyp[2]=false;
    out_names.push_back(" ");

  } else if (type1=="PS Model 740") { // analog FAN-IN FAN-OUT
    logic_type=2;
    Xsize=10.;
    Ysize=20.;
    ninput=4;
    nout=6;
    for (int i=0; i<ninput; i++) {
      intyp[i] =true;
      in_names.push_back(" ");
    }
    for (int i=0; i<4;   i++) {
      outtyp[i]=true;
      out_names.push_back(" ");
    }
    for (int i=4; i<6;   i++) {
      outtyp[i]=false;
      out_names.push_back(" ");
    }

  } else if (type1=="LeCroy 428F") { // analog FAN-IN FAN-OUT
    logic_type=2;
    Xsize=10.;
    Ysize=20.;
    ninput=4;
    nout=4;
    for (int i=0; i<ninput; i++) {
      intyp[i] =true;
      in_names.push_back(" ");
    }
    for (int i=0; i<nout;   i++) {
      outtyp[i]=switch_set;
      out_names.push_back(" ");
    }

  } else if (type1=="LRS 429.4") { // LRS 429 4x4 logical FAN-IN FAN-OUT
    logic_type=3;
    Xsize=10.;
    Ysize=20.;
    ninput=4;
    nout=6;
    for (int i=0; i<ninput; i++) {
      intyp[i] =true;
      in_names.push_back(" ");
    }
    for (int i=0; i<4;      i++) {
      outtyp[i]=true;
      out_names.push_back(" ");
    }
    for (int i=4; i<6;      i++) {
      outtyp[i]=false;
      out_names.push_back(" ");
    }

  } else if (type1=="LRS 429.8") { // LRS 429 2x8 logical FAN-IN FAN-OUT
    logic_type=4;
    Xsize=10.;
    Ysize=40.;
    ninput=8;
    nout=12;
    for (int i=0; i<ninput; i++) {
      intyp[i] =true;
      in_names.push_back(" ");
    }
    for (int i=0; i<8;      i++) {
      outtyp[i]=true;
      out_names.push_back(" ");
    }
    for (int i=8; i<12;     i++) {
      outtyp[i]=false;
      out_names.push_back(" ");
    }

  } else if (type1=="LRS 429.16") { // LRS 429 1x16 logical FAN-IN FAN-OUT
    logic_type=5;
    ninput=16;
    Xsize=10.;
    Ysize=80.;
    nout=24;
    for (int i=0; i<ninput; i++) {
      intyp[i] =true;
      in_names.push_back(" ");
    }
    for (int i=0; i<ninput; i++) {
      outtyp[i]=true;
      out_names.push_back(" ");
    }
    for (int i=ninput; i<3*ninput/2; i++) {
      outtyp[i]=false;
      out_names.push_back(" ");
    }

  } else if (type1=="LeCroy 222") { // Dual Gate
    logic_type=6;
    Xsize=15.;
    Ysize=30.;
    ninput=4;
    nout=4;

    for (int i=0; i<ninput; i++) {
      intyp[i] =true;
    }
    in_names.push_back("S");
    in_names.push_back("R");
    in_names.push_back("OR");
    in_names.push_back("Blank");

    outtyp[0]=true;
    out_names.push_back("NIM");
    outtyp[1]=false;
    out_names.push_back("NIM");
    outtyp[2]=true;
    out_names.push_back("TTL");
    outtyp[3]=true;
    out_names.push_back("DEL");

  } else if (type1=="LeCroy 688AL") { // LeCroy 688AL level adaptor
    logic_type=7;
    ninput=1;
    Xsize=15.;
    Ysize=6.;
    nout=1;
    intyp[0]=true;
    outtyp[0]=switch_set;
    if (unit<8) {
      in_names.push_back("NIM");
      out_names.push_back("TTL");
    } else {
      in_names.push_back("TTL");
      out_names.push_back("NIM");
    }

  } else if (type1=="LeCroy 623") { // 8-fold discr
    logic_type=8;
    Xsize=10.;
    Ysize=15.;
    ninput=1;
    nout=3;
    for (int i=0; i<ninput; i++) {
      intyp[i] =true;
      in_names.push_back(" ");
    }
    for (int i=0; i<3;      i++) {
      outtyp[i]=true;
      out_names.push_back(" ");
    }

  } else if (type1=="LeCroy 621") { // 4-fold discr
    logic_type=9;
    Xsize=10.;
    Ysize=25.;
    ninput=1;
    nout=6;
    for (int i=0; i<ninput; i++) {
      intyp[i] =true;
      in_names.push_back(" ");
    }
    for (int i=0; i<5;      i++) {
      outtyp[i]=true;
      out_names.push_back(" ");
    }
    outtyp[5]=false;
    out_names.push_back(" ");

//==========================================
//  special non-NIM units
//==========================================
  } else if (type1=="PMT") {
    logic_type=100;
    Xsize=10.;
    Ysize=6.;
    ninput=0;
    nout=1;
    for (int i=0; i<nout; i++) {
      outtyp[i]=true;
      out_names.push_back(" ");
    }

  } else if (type1=="Delay") {
    Xsize=10.;
    Ysize=6.;
    logic_type=101;
    ninput=1;
    nout=1;
    for (int i=0; i<ninput; i++) {
      intyp[i] =true;
      in_names.push_back(" ");
    }
    for (int i=0; i<nout;   i++) {
      outtyp[i]=true;
      out_names.push_back(" ");
    }

  } else if (type1=="INPUT") {
    Xsize=10.;
    Ysize=6.;
    logic_type=102;
    ninput=0;
    nout=1;
    for (int i=0; i<nout; i++) {
      outtyp[i]=true;
      out_names.push_back(" ");
    }

  } else if (type1=="OUTPUT") {
    Xsize=10.;
    Ysize=6.;
    logic_type=103;
    ninput=1;
    nout=0;
    for (int i=0; i<ninput; i++) {
      intyp[i]=true;
      in_names.push_back(" ");
    }

  } else if (type1=="CAEN DT5730") { // Digitizer
    logic_type=104;
    Xsize=15.;
    Ysize=30.;
    ninput=3;
    nout=1;

    for (int i=0; i<ninput; i++) {
      intyp[i] =true;
    }
    in_names.push_back("Trig");
    in_names.push_back("Ch6");
    in_names.push_back("Ch7");

    outtyp[0]=true;
    out_names.push_back("Busy");


  } else if (type1=="dot") {
    Xsize=0.;
    Ysize=0.;
    logic_type=999;
    ninput=1;
    nout=1;
    for (int i=0; i<ninput; i++) {
      intyp[i]=true;
      in_names.push_back(" ");
    }
    for (int i=0; i<nout; i++) {
      outtyp[i]=true;
      in_names.push_back(" ");
    }

  } else {
    printf("unknown type of module %s, bye\n", type);
  }

  for (int i=0; i<ninput; i++) {
    xin0[i]=X-Xsize*scale;
    xin1[i]=X-1.2*Xsize*scale;
    yin0[i]=Y+Ysize*scale-Ysize*scale*(1.+2.0*i)/ninput;
  }
  for (int i=0; i<nout; i++) {
    xout0[i]=X+Xsize*scale;
    xout1[i]=X+1.2*Xsize*scale;
    yout0[i]=Y+Ysize*scale-Ysize*scale*(1.+2.0*i)/nout;
  }
}

//===========================================================
void Set_XY(double x, double y) {
  X=x;
  Y=y;
  for (int i=0; i<ninput; i++) {
    xin0[i]=X-Xsize*scale;
    xin1[i]=X-1.2*Xsize*scale;
    yin0[i]=Y+Ysize*scale-Ysize*scale*(1.+2.0*i)/ninput;
  }
  for (int i=0; i<nout; i++) {
    xout0[i]=X+Xsize*scale;
    xout1[i]=X+1.2*Xsize*scale;
    yout0[i]=Y+Ysize*scale-Ysize*scale*(1.+2.0*i)/nout;
  }
}

//===========================================================
void Set_ID(int id) {
  ID=id;
  sprintf(IDname, "%d", ID);
}

//===========================================================
void Draw(int iOpt) {
printf("[Draw] %s\n", name);
if (logic_type==999) { return;} // dot
if (logic_type==100) { //  PMT
  myBox->SetFillColor(kGray+1);
  myBox->DrawBox(X-Xsize*scale,     Y-Ysize*scale,     X+Xsize*scale, Y+Ysize*scale);
  myBox->SetFillColor(kAzure-9);
  myBox->DrawBox(X-2.0*Xsize*scale, Y-0.5*Ysize*scale, X-Xsize*scale, Y+0.5*Ysize*scale);
  myLatex->SetTextAlign(22);
  myLatex->SetTextSize(0.05*scale);
  myLatex->DrawLatex(X, Y, name);
} else if (logic_type==101) { // Delay
  myBox  ->DrawBox(X-Xsize*scale, Y-Ysize*scale, X+Xsize*scale, Y+Ysize*scale);
  myLine->DrawLine(X-Xsize*scale, Y-Ysize*scale, X-Xsize*scale, Y+Ysize*scale);
  myLine->DrawLine(X+Xsize*scale, Y-Ysize*scale, X+Xsize*scale, Y+Ysize*scale);
  myLine->DrawLine(X-Xsize*scale, Y-Ysize*scale, X+Xsize*scale, Y-Ysize*scale);
  myLine->DrawLine(X-Xsize*scale, Y+Ysize*scale, X+Xsize*scale, Y+Ysize*scale);
  myLatex->SetTextAlign(22);
  myLatex->SetTextSize(0.05*scale);
  myLatex->DrawLatex(X, Y, name);
} else if (logic_type==102) { // INPUT
  myBox->SetFillColor(kGreen-9);
  myBox  ->DrawBox(X-Xsize*scale, Y-Ysize*scale, X+Xsize*scale, Y+Ysize*scale);
  myLine->DrawLine(X-Xsize*scale, Y-Ysize*scale, X-Xsize*scale, Y+Ysize*scale);
  myLine->DrawLine(X+Xsize*scale, Y-Ysize*scale, X+Xsize*scale, Y+Ysize*scale);
  myLine->DrawLine(X-Xsize*scale, Y-Ysize*scale, X+Xsize*scale, Y-Ysize*scale);
  myLine->DrawLine(X-Xsize*scale, Y+Ysize*scale, X+Xsize*scale, Y+Ysize*scale);
  myLatex->SetTextAlign(22);
  myLatex->SetTextSize(0.05*scale);
  myLatex->DrawLatex(X, Y, name);
} else if (logic_type==103) { // OUTPUT
  myBox->SetFillColor(kRed-9);
  myBox  ->DrawBox(X-Xsize*scale, Y-Ysize*scale, X+Xsize*scale, Y+Ysize*scale);
  myLine->DrawLine(X-Xsize*scale, Y-Ysize*scale, X-Xsize*scale, Y+Ysize*scale);
  myLine->DrawLine(X+Xsize*scale, Y-Ysize*scale, X+Xsize*scale, Y+Ysize*scale);
  myLine->DrawLine(X-Xsize*scale, Y-Ysize*scale, X+Xsize*scale, Y-Ysize*scale);
  myLine->DrawLine(X-Xsize*scale, Y+Ysize*scale, X+Xsize*scale, Y+Ysize*scale);
  myLatex->SetTextAlign(22);
  myLatex->SetTextSize(0.05*scale);
  myLatex->DrawLatex(X, Y, name);
} else if (logic_type==104) { // CAEN DT5730
  myLine->SetLineColor(kRed);
  myBox  ->DrawBox(X-Xsize*scale, Y-Ysize*scale, X+Xsize*scale, Y+Ysize*scale);
  myLine->DrawLine(X-Xsize*scale, Y-Ysize*scale, X-Xsize*scale, Y+Ysize*scale);
  myLine->DrawLine(X+Xsize*scale, Y-Ysize*scale, X+Xsize*scale, Y+Ysize*scale);
  myLine->DrawLine(X-Xsize*scale, Y-Ysize*scale, X+Xsize*scale, Y-Ysize*scale);
  myLine->DrawLine(X-Xsize*scale, Y+Ysize*scale, X+Xsize*scale, Y+Ysize*scale);
  myLatex->SetTextAlign(22);
  myLatex->SetTextSize(0.05*scale);
  myLatex->DrawLatex(X, Y+1.05*Ysize*scale, name);
} else {
//  myBox->SetFillColor(kGray);
  myBox ->DrawBox (X-Xsize*scale, Y-Ysize*scale, X+Xsize*scale, Y+Ysize*scale);
  myLine->DrawLine(X-Xsize*scale, Y-Ysize*scale, X-Xsize*scale, Y+Ysize*scale);
  myLine->DrawLine(X+Xsize*scale, Y-Ysize*scale, X+Xsize*scale, Y+Ysize*scale);
  myLine->DrawLine(X-Xsize*scale, Y-Ysize*scale, X+Xsize*scale, Y-Ysize*scale);
  myLine->DrawLine(X-Xsize*scale, Y+Ysize*scale, X+Xsize*scale, Y+Ysize*scale);
  myLatex->SetTextAlign(21);
  myLatex->SetTextSize(0.05*scale);
  myLatex->DrawLatex(X, Y+1.05*Ysize*scale, name);
}

if (iOpt==2) {
  myLatex->SetTextAlign(22);
  myLatex->SetTextSize(0.05*scale);
  myLatex->DrawLatex(X, Y-(Ysize+4.)*scale, IDname);
}

if (iOpt==1 || iOpt==2) {
  if (crate>-1) {
    myLatex->SetTextSize(0.04*scale);
    myLatex->SetTextAlign(23);
    sprintf(text, "%d.%d.%d", crate, station, unit);
    myLatex->DrawLatex(X, Y+(Ysize-5.0)*scale, text);
  }
}

if (logic_type==0) { // "AND"
  myLatex->SetTextSize(0.04*scale);
  myLatex->SetTextAlign(23);
  myLatex->DrawLatex(X, Y+(Ysize-1.2)*scale, "AND");
} else if (logic_type==1) { // "Discriminator"
  myLatex->SetTextSize(0.04*scale);
  myLatex->SetTextAlign(23);
  myLatex->DrawLatex(X, Y+(Ysize-1.2)*scale, "DISCR.");
} else if (logic_type==2) { // "FAN IN - FAN OUT"
  myLatex->SetTextSize(0.04*scale);
  myLatex->SetTextAlign(23);
  myLatex->DrawLatex(X, Y+(Ysize-1.2)*scale, "A-FAN");
} else if (logic_type>2 && logic_type<6) { // "OR"
  myLatex->SetTextSize(0.04*scale);
  myLatex->SetTextAlign(23);
  myLatex->DrawLatex(X, Y+(Ysize-1.2)*scale, "OR");
} else if (logic_type==6) { // "Dual Gate"
  myLatex->SetTextSize(0.04*scale);
  myLatex->SetTextAlign(23);
  myLatex->DrawLatex(X, Y+(Ysize-1.2)*scale, "Gate");
} else if (logic_type==8) { // "Discriminator"
  myLatex->SetTextSize(0.04*scale);
  myLatex->SetTextAlign(23);
  myLatex->DrawLatex(X, Y+(Ysize-1.2)*scale, "DISCR.");
} else if (logic_type==9) { // "Discriminator"
  myLatex->SetTextSize(0.04*scale);
  myLatex->SetTextAlign(23);
  myLatex->DrawLatex(X, Y+(Ysize-1.2)*scale, "DISCR.");
} else if (logic_type==104) { // "CAEN DT5730"
  myLatex->SetTextSize(0.04*scale);
  myLatex->SetTextAlign(23);
  myLatex->DrawLatex(X, Y+(Ysize-1.2)*scale, "DT5730");


//==============================================
} else if (logic_type==100) { // "PMT"
} else if (logic_type==101) { // "Delay"
} else if (logic_type==102) { // "Input"
} else if (logic_type==103) { // "Output"
}

myLine->SetLineColor(kBlack);
//----------------------------------------------------
for (int i=0; i<ninput; i++) {
  myLine->DrawLine(xin0[i], yin0[i], xin1[i], yin0[i]);
  if (!intyp[i]) myArc->DrawArc(xin0[i], yin0[i], 1.25*scale);
  if (in_names.at(i) != " ") {
    myLatex->SetTextSize(0.04*scale);
    myLatex->SetTextColor(kBlack);
    myLatex->SetTextAlign(12);
    strcpy(text, in_names.at(i).c_str());
    myLatex->DrawLatex(xin0[i]+2.0*scale, yin0[i], text);
  }
}
for (int i=0; i<nout; i++) {
  myLine->DrawLine(xout0[i], yout0[i], xout1[i], yout0[i]);
  if (!outtyp[i]) myArc->DrawArc(xout0[i], yout0[i], 1.25*scale);
  if (out_names.at(i) != " ") {
    myLatex->SetTextSize(0.04*scale);
    myLatex->SetTextColor(kBlack);
    myLatex->SetTextAlign(32);
    strcpy(text, out_names.at(i).c_str());
    myLatex->DrawLatex(xout0[i]-2.0*scale, yout0[i], text);
  }
}
}
//===========================================================
bool DrawInCrate(int cr, int iOpt) {
if (crate==-1) return false;
if (cr != crate) {
  printf("wrong crate#%d for unit#%d\n", crate, ID);
  return false;
}
double x=station*10.+5.;
double y=0.;
double h=0.;
double htot=150.;

printf("Drawing unit#%d station#%d unit#%d x=%.2f ", ID, station, unit, x);

if (logic_type==0) {// 4-fold logic unit
  sprintf(text, "AND");
  h=htot/2.;
  y=htot-h*(unit+0.5);

} else if (logic_type==1) { // 5-fold Risetime compensated discr.
  sprintf(text, "Discr 5");
  h=htot/5.;
  y=htot-h*(unit+0.5);

} else if (logic_type==2) { // analog FAN-IN FAN-OUT
  sprintf(text, "A-FAN");
  h=htot/4.;
  y=htot-h*(unit+0.5);

} else if (logic_type==3) { // 4x4 logical FAN-IN FAN-OUT
  sprintf(text, "4-OR");
  h=htot/4.;
  y=htot-h*(unit+0.5);

} else if (logic_type==4) { // 2x8 logical FAN-IN FAN-OUT
  sprintf(text, "8-OR");
  h=htot/2.;
  y=htot-h*(unit+0.5);

} else if (logic_type==5) { // 1x16 logical FAN-IN FAN-OUT
  sprintf(text, "16-OR");
  h=htot/1.;
  y=htot-h*(unit+0.5);

} else if (logic_type==6) { // Dual Gate
  sprintf(text, "Gate");
  h=htot/2.;
  y=htot-h*(unit+0.5);

} else if (logic_type==7) { // NIM-TTL converter
  sprintf(text, "TTL-NIM");
  h=htot/16.;
  y=htot-h*(unit+0.5);

} else if (logic_type==8) { // Octal Discriminator
  sprintf(text, "8 Discr");
  h=htot/8.;
  y=htot-h*(unit+0.5);

} else if (logic_type==9) { // Quad Discriminator
  sprintf(text, "4 Discr");
  h=htot/4.;
  y=htot-h*(unit+0.5);

} else {
  printf("unknown logic type %d, bye\n", logic_type);
  exit(-1);
}

printf(" h=%.2f y=%.2f\n", h, y);
myBox ->DrawBox( x-4.6, y+0.48*h, x+4.6, y-0.48*h);
myLine->SetLineWidth(1);
myLine->DrawLine(x-4.6, y+0.48*h, x-4.6, y-0.48*h);
myLine->DrawLine(x+4.6, y+0.48*h, x+4.6, y-0.48*h);
myLine->DrawLine(x-4.6, y+0.48*h, x+4.6, y+0.48*h);
myLine->DrawLine(x-4.6, y-0.48*h, x+4.6, y-0.48*h);
myLatex->SetTextSize(0.04);
myLatex->SetTextAlign(22);
myLatex->DrawLatex(x, 0.5*(160.+htot), text);


myLatex->SetTextAlign(23);
myLatex->SetTextSize(0.04);
myLatex->DrawLatex(x, y+0.50*h-2, name);

if (iOpt==2) {
  myLatex->SetTextAlign(23);
  myLatex->SetTextSize(0.04);
  myLatex->DrawLatex(x, y+0.5*h-22, IDname);
}
if (iOpt==1 || iOpt==2) {
  myLatex->SetTextSize(0.04);
  myLatex->SetTextAlign(23);
  sprintf(text, "%d.%d.%d", crate, station, unit);
  myLatex->DrawLatex(x, y+0.5*h-12, text);
}
return true;
}
//===========================================================
void connect_out_in(int iOut, logic_unit lu, int iIn, double frac, int LW) {
  double x0=xout1[iOut];
  double x1=lu.get_x_in(iIn);
  double y0=yout0[iOut];
  double y1=lu.get_y_in(iIn);
  double xi=frac*x1+(1.0-frac)*x0;
  myLine->SetLineWidth(LW);
  myLine->SetLineColor(kBlack);
  myLine->DrawLine(x0, y0, xi, y0);
  myLine->DrawLine(xi, y0, xi, y1);
  myLine->DrawLine(xi, y1, x1, y1);
}
//===========================================================
void align_in_out(int iIn, logic_unit lu, int iOut, double dx, double dy) {
  double x0=xin1[iIn];
  double x1=lu.get_x_out(iOut);
  double y0=yin0[iIn];
  double y1=lu.get_y_out(iOut);
  Set_XY(x1-x0+dx, y1-y0+dy);
}
//===========================================================
double get_x_out(int i) {return xout1[i];}
double get_y_out(int i) {return yout0[i];}
double get_x_in(int i)  {return xin1[i];}
double get_y_in(int i)  {return yin0[i];}
double get_X()          {return X;}
double get_Y()          {return Y;}
std::string get_name()  {return name1;}
int    get_type()       {return logic_type;}
int    get_ID()         {return ID;}
int    get_crate()      {return crate;}
int    get_station()    {return station;}
int    get_unit()       {return unit;}
//===========================================================
void   Print() {
  printf("id=%4d %20s %20s X=%6.2f Y=%6.2f\n", ID, name, type, X, Y);
}
//===========================================================
};

std::string convertToString(char* a)
{
    string s(a);
    return s;
}

//===========================
void trigger20210601() {
//===========================

std::vector<logic_unit> platformUnits;
std::vector<logic_unit> triggerUnits1;
std::vector<logic_unit> triggerUnits2;

int id;
double x_in=0.;
double y_in=0.;
double x_out=0.;
double y_out=0.;
double x_out1=0.;
double y_out1=0.;
double x_out2=0.;
double y_out2=0.;
double x_out3=0.;
double y_out3=0.;
double x_out4=0.;
double y_out4=0.;

double x_2=0.;
double y_2=0.;

TLatex* myLatex  = new TLatex();
TBox*   myModule = new TBox();
myModule->SetFillColor(kWhite);
TLine* myLine = new TLine();

TCanvas* Canvas0 = new TCanvas("Canvas0", "Platform",              400, 0, 800, 1200);
TCanvas* Canvas1 = new TCanvas("Canvas1", "Barracks 1",           1200, 0, 800, 1200);
TCanvas* Canvas2 = new TCanvas("Canvas2", "Barracks 2",           2000, 0, 800, 1200);
TCanvas* Canvas3 = new TCanvas("Canvas3", "Crates",               2800, 0, 800, 1200);
TH2F* drawing0 = new TH2F("drawing0", "", 200, 0., 100., 200, 0., 160.);
TH2F* drawing1 = new TH2F("drawing1", "", 200, 0., 100., 200, 0., 160.);
TH2F* drawing2 = new TH2F("drawing2", "", 200, 0., 120., 200, 0., 170.);
TH2F* drawing3 = new TH2F("drawing3", "", 200, 0., 120., 200, 0., 170.);
TH2F* drawing4 = new TH2F("drawing4", "", 200, 0., 120., 200, 0., 170.);
drawing0->SetStats(0);
drawing1->SetStats(0);
drawing2->SetStats(0);
drawing3->SetStats(0);
drawing4->SetStats(0);
gPad->SetTopMargin(0.03);
gPad->SetRightMargin(0.03);
gPad->SetBottomMargin(0.03);
gPad->SetLeftMargin(0.03);

for (int i=0; i<8; i++) {
  char nm[20];
  if (i<4) {
    sprintf(nm, "S%d", i+1);
  } else if (i<6) {
    sprintf(nm, "Leak%d", i-3);
  } else if (i<8) {
    sprintf(nm, "Halo%d", i-5);
  }
//  int nm_size=sizeof(nm)/sizeof(char);
  std::string sname=convertToString(nm);

  logic_unit pmt1;
  id=(int)platformUnits.size();
  pmt1.Set_Unit("PMT", id, -1, -1, -1, 1, 7., 140.-15.0*i, .25, sname);
  pmt1.Print();
  platformUnits.push_back(pmt1);
}

int nTot=(int) platformUnits.size();

int station=0;
int unit=0;

for (int i=0; i<6; i++) { // S1,2,3,4 Leak1 and Leak 2 fan out
  std::string sname=platformUnits.at(i).get_name();
  logic_unit af1;
  int ist=station;
  int iun=unit;
  id=(int)platformUnits.size();
  af1.Set_Unit("LeCroy 428F", id, 0, ist, iun, 1, 0., 0., .25, sname);
  y_out=platformUnits.at(i).get_y_out(0);
  x_out=platformUnits.at(i).get_x_out(0);
  y_in=af1.get_y_in(0);
  x_in=af1.get_x_in(0);
  af1.Set_XY(x_out-x_in+2., y_out-y_in);
  af1.Print();
  platformUnits.push_back(af1);
  unit++;
  if (unit==4) {
    unit=0;
    station++;
  }
}

logic_unit vf1;
id=(int)platformUnits.size();
vf1.Set_Unit("LeCroy 428F", id, 0, station, unit, 1, 0., 0., .25, "Halo");
y_out=platformUnits.at(6).get_y_out(0);
x_out=platformUnits.at(6).get_x_out(0);
y_in=vf1.get_y_in(0);
x_in=vf1.get_x_in(0);
vf1.Set_XY(x_out-x_in+2., y_out-y_in);
vf1.Print();
platformUnits.push_back(vf1);
unit++;
if (unit==4) {
  unit=0;
  station++;
}

//=================================
// delays
nTot=(int) platformUnits.size();
int iDelay=0;
std::vector<int> beam_delays;
for (int iu=0; iu<nTot; iu++) {
  if (platformUnits.at(iu).get_type()==2) {
    std::string dname;
    if      (iDelay==0 || iDelay==4) dname="0ns";
    else if (iDelay==1 || iDelay==5) dname="80ns";
    else if (iDelay==2 || iDelay==6) dname="160ns";
    else if (iDelay==3)              dname="240ns";

    logic_unit delay;
    id=(int)platformUnits.size();
    delay.Set_Unit("Delay", id, -1, -1, -1, 1, 0., 0., .25, dname);
    x_out=platformUnits.at(iu).get_x_out(1);
    y_out=platformUnits.at(iu).get_y_out(1);
    y_in=delay.get_y_in(0);
    x_in=delay.get_x_in(0);
    delay.Set_XY(x_out-x_in+4., y_out-y_in);
    platformUnits.push_back(delay);
    beam_delays.push_back(platformUnits.size()-1);
    iDelay++;
  }
}

double x_sum1=platformUnits.at(15).get_X()+20.;
logic_unit sum1;
id=(int)platformUnits.size();
sum1.Set_Unit("LeCroy 428F", id, 0, station, unit, 1, x_sum1, 0., .25, "Sum 1");
y_out=platformUnits.at(15).get_y_out(0);
y_in =sum1.get_y_in(0);
sum1.Set_XY(x_sum1, y_out-y_in);
sum1.Print();
platformUnits.push_back(sum1);
unit++;
if (unit==4) {
  unit=0;
  station++;
}

x_2=platformUnits.at(19).get_X()+20.;
logic_unit sum2;
id=(int)platformUnits.size();
sum2.Set_Unit("LeCroy 428F", id, 0, station, unit, 1, x_2, 0., .25, "Sum 2");
y_out=platformUnits.at(19).get_y_out(0);
y_in =sum2.get_y_in(0);
sum2.Set_XY(x_2, y_out-y_in);
sum2.Print();
platformUnits.push_back(sum2);
unit++;
if (unit==4) {
  unit=0;
  station++;
}

logic_unit in_trig;
id=(int)platformUnits.size();
in_trig.Set_Unit("INPUT", id, -1, -1, -1, 1, 7., 140.-15.0*8, .25, "> Trig");
x_out=in_trig.get_x_out(0);
y_out=in_trig.get_y_out(0);
in_trig.Print();
platformUnits.push_back(in_trig);

logic_unit trig_fan;
id=(int)platformUnits.size();
trig_fan.Set_Unit("LRS 429.4", id, 0, 3, 0, 1, 0., 0., .25, "Trig");
x_in=trig_fan.get_x_in(0);
y_in=trig_fan.get_y_in(0);
trig_fan.Set_XY(platformUnits.at(14).get_X(), y_out-y_in);
trig_fan.Print();
platformUnits.push_back(trig_fan);


// trigger delay to ADC Sum2
logic_unit delay;
id=(int)platformUnits.size();
double x_dt=platformUnits.at(21).get_X();
double y_dt=platformUnits.at(25).get_y_out(0);
delay.Set_Unit("Delay", id, -1, -1, -1, 1, x_dt, y_dt, .25, "??? ns");
platformUnits.push_back(delay);


logic_unit out_counters;
x_out=platformUnits.at(15).get_X();
y_out=platformUnits.at(15).get_Y()+8.;
id=(int)platformUnits.size();
out_counters.Set_Unit("OUTPUT", id, -1, -1, -1, 1, x_out, y_out, .25, "Beam >");
out_counters.Print();
platformUnits.push_back(out_counters);


logic_unit out_sums;
x_out=platformUnits.at(23).get_X()+10;
y_out=platformUnits.at(27).get_Y();
id=(int)platformUnits.size();
out_sums.Set_Unit("OUTPUT", id, -1, -1, -1, 1, x_out, y_out, .25, "Sums >");
out_sums.Print();
platformUnits.push_back(out_sums);

logic_unit dig2;
id=(int)platformUnits.size();
dig2.Set_Unit("CAEN DT5730", id, -1, -1, -1, 1, 0., 0., .25, "Dig 2");
x_out=platformUnits.at(22).get_x_out(1);
x_in=dig2.get_x_in(1);
y_out=platformUnits.at(22).get_y_out(1);
y_in=dig2.get_y_in(1);
dig2.Set_XY(x_out-x_in+7., y_out-y_in);
dig2.Print();
platformUnits.push_back(dig2);

logic_unit dig1;
id=(int)platformUnits.size();
dig1.Set_Unit("CAEN DT5730", id, -1, -1, -1, 1, x_out-x_in+7., y_out-y_in-30., .25, "Dig 1");
dig1.Print();
platformUnits.push_back(dig1);

logic_unit dig0;
id=(int)platformUnits.size();
dig0.Set_Unit("CAEN DT5730", id, -1, -1, -1, 1, x_out-x_in+7., y_out-y_in-60., .25, "Dig 0");
dig0.Print();
platformUnits.push_back(dig0);

logic_unit busy_fan;
id=(int)platformUnits.size();
busy_fan.Set_Unit("LRS 429.4", id, 0, 3, 1, 1, 0., 0., .25, "Busy1");
x_out=dig2.get_x_out(0);
y_out=dig2.get_y_out(0);
x_in =busy_fan.get_x_in(0);
y_in =busy_fan.get_y_in(0);
busy_fan.Set_XY(x_out-x_in+5., y_out-y_in);
busy_fan.Print();
platformUnits.push_back(busy_fan);

logic_unit out_busy;
x_out=platformUnits.at(32).get_x_out(0);
y_out=platformUnits.at(28).get_y_in(0);
id=(int)platformUnits.size();
out_busy.Set_Unit("OUTPUT", id, -1, -1, -1, 1, x_out+5., y_out, .25, "Busy1 >");
out_busy.Print();
platformUnits.push_back(out_busy);






//=====================================

Canvas0->Clear();
Canvas0->cd(0)->SetGrid(1);
gPad->SetTopMargin(0.03);
gPad->SetRightMargin(0.03);
gPad->SetBottomMargin(0.03);
gPad->SetLeftMargin(0.03);
drawing0->DrawCopy("A");
myLatex->SetTextSize(0.05);
myLatex->SetTextAlign(21);
myLatex->DrawLatex(50., 152., "Beam Area");
int nDraw=(int) platformUnits.size();
for (int iu=0; iu<nDraw; iu++) {
  platformUnits.at(iu).Draw(1);
}

// wire PMTs to FAN-OUT
for (int iu=0; iu<6; iu++) {
  platformUnits.at(iu).connect_out_in(0, platformUnits.at(iu+8), 0, 0.5, 1);
}
platformUnits.at(6).connect_out_in(0, platformUnits.at(14), 0, 0.5, 1);
platformUnits.at(7).connect_out_in(0, platformUnits.at(14), 1, 0.5, 1);

// wire delays and signals to Barracks
for (int iu=8; iu<15; iu++) {
  platformUnits.at(iu).connect_out_in(1, platformUnits.at(iu+7), 0, 2./3., 1);
  platformUnits.at(iu).connect_out_in(0, platformUnits.at(27),   0, 0.5,   3);
}

// wire Sums
for (int i=0; i<(int)beam_delays.size(); i++) {
  if (i<4) {
    platformUnits.at(beam_delays.at(i)).connect_out_in(0, sum1, i,  0.1+0.2*i,      1);
  } else if (i<8) {
    platformUnits.at(beam_delays.at(i)).connect_out_in(0, sum2, i-4, 0.1+0.2*(i-4), 1);
  }
}
// wire trigger to logic fan-out
platformUnits.at(24).connect_out_in(0, platformUnits.at(25), 0, 0.50, 1);
// wire logic fan-out to delay
platformUnits.at(25).connect_out_in(0, platformUnits.at(26), 0, 0.50, 1);
// wire delay to sum2
platformUnits.at(26).connect_out_in(0, platformUnits.at(23), 3, 0.95, 1);
// wire Sum1 and Sum2 to Sums barrack
platformUnits.at(22).connect_out_in(0, platformUnits.at(28), 0, 0.50, 3);
platformUnits.at(23).connect_out_in(0, platformUnits.at(28), 0, 0.50, 3);
// wire Sum1 to ch#6 of dig2 and Sum2 to ch#7 of dig2
platformUnits.at(22).connect_out_in(1, platformUnits.at(29), 1, 0.50, 1);
platformUnits.at(23).connect_out_in(1, platformUnits.at(29), 2, 0.45, 1);
// wire trigger fan-out to digitizers
platformUnits.at(25).connect_out_in(1, platformUnits.at(29), 0, 0.92, 1);
platformUnits.at(25).connect_out_in(2, platformUnits.at(30), 0, 0.95, 1);
platformUnits.at(25).connect_out_in(3, platformUnits.at(31), 0, 0.98, 1);
// wire digitizers busy to logic sum
platformUnits.at(29).connect_out_in(0, platformUnits.at(32), 0, 0.50, 1);
platformUnits.at(30).connect_out_in(0, platformUnits.at(32), 1, 0.33, 1);
platformUnits.at(31).connect_out_in(0, platformUnits.at(32), 2, 0.66, 1);
// wire digitizers logic sum to barracks
platformUnits.at(32).connect_out_in(0, platformUnits.at(33), 0, 0.50, 1);

myLatex->SetTextSize(0.02);
myLatex->SetTextAlign(21);
myLatex->DrawLatex(out_busy.get_X(),     out_busy.get_Y()+2.,     "Trig.1");
myLatex->DrawLatex(out_counters.get_X(), out_counters.get_Y()+2., "Trig.2");
myLatex->DrawLatex(out_sums.get_X(),     out_sums.get_Y()+2.,     "Trig.2");
myLatex->DrawLatex(in_trig.get_X(),      in_trig.get_Y()+2.,      "Trig.2");


Canvas0->Update();
Canvas0->Print("trigger.ps(");
//================================================================================

//=====================================================================
// Trigger #1 (slow)
//=====================================================================

logic_unit in_beam1;
id=(int)triggerUnits1.size();
in_beam1.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 145., .35, "> Spill0");
x_out=in_beam1.get_x_out(0);
y_out=in_beam1.get_y_out(0);
in_beam1.Print();
triggerUnits1.push_back(in_beam1);

logic_unit level1;
id=(int)triggerUnits1.size();
level1.Set_Unit("LeCroy 688AL", id, 1, 0, 8, 1, 0., 0., .25, "Pre-Spill");
x_in=level1.get_x_in(0);
y_in=level1.get_y_in(0);
level1.Set_XY(x_out-x_in+0., y_out-y_in);
x_out=level1.get_x_out(0);
y_out=level1.get_y_out(0);
level1.Print();
triggerUnits1.push_back(level1);

logic_unit disc_spill1;
id=(int)triggerUnits1.size();
disc_spill1.Set_Unit("LeCroy 623", id, 1, 1, 0, 1, 0., 0., .25, "Pre-Spill");
x_in=disc_spill1.get_x_in(0);
y_in=disc_spill1.get_y_in(0);
disc_spill1.Set_XY(x_out-x_in+0., y_out-y_in);
disc_spill1.Print();
triggerUnits1.push_back(disc_spill1);
//=====================================================================





logic_unit in_beam2;
id=(int)triggerUnits1.size();
in_beam2.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 133., .35, "> SoS");
x_out=in_beam2.get_x_out(0);
y_out=in_beam2.get_y_out(0);
in_beam2.Print();
triggerUnits1.push_back(in_beam2);

logic_unit level2;
id=(int)triggerUnits1.size();
level2.Set_Unit("LeCroy 688AL", id, 1, 0, 9, 1, 0., 0., .25, "SoS");
x_in=level2.get_x_in(0);
y_in=level2.get_y_in(0);
level2.Set_XY(x_out-x_in+0., y_out-y_in);
x_out=level2.get_x_out(0);
y_out=level2.get_y_out(0);
level2.Print();
triggerUnits1.push_back(level2);

logic_unit disc_spill2;
id=(int)triggerUnits1.size();
disc_spill2.Set_Unit("LeCroy 623", id, 1, 1, 1, 1, 0., 0., .25, "SoS");
x_in=disc_spill2.get_x_in(0);
y_in=disc_spill2.get_y_in(0);
disc_spill2.Set_XY(x_out-x_in+0., y_out-y_in);
x_out=disc_spill2.get_x_out(2);
y_out=disc_spill2.get_y_out(2);
disc_spill2.Print();
triggerUnits1.push_back(disc_spill2);

logic_unit fan_spill2;
id=(int)triggerUnits1.size();
fan_spill2.Set_Unit("LRS 429.4", id, 1, 3, 1, 1, 0., 0., .25, "SoS");
x_in=fan_spill2.get_x_in(0);
y_in=fan_spill2.get_y_in(0);
fan_spill2.Set_XY(x_out-x_in+1., y_out-y_in);
x_out=fan_spill2.get_x_out(2);
y_out=fan_spill2.get_y_out(2);
fan_spill2.Print();
triggerUnits1.push_back(fan_spill2);

logic_unit spill_delay;
id=(int)triggerUnits1.size();
spill_delay.Set_Unit("LeCroy 222", id, 1, 4, 0, 1, 0., 0., .25, "Delay 1");
x_in=spill_delay.get_x_in(0);
y_in=spill_delay.get_y_in(0);
spill_delay.Set_XY(x_out-x_in+5., y_out-y_in);
x_out=spill_delay.get_x_out(0);
y_out=spill_delay.get_y_out(0);
spill_delay.Print();
triggerUnits1.push_back(spill_delay);

logic_unit spillG;
id=(int)triggerUnits1.size();
spillG.Set_Unit("LeCroy 222", id, 1, 4, 1, 1, 0., 0., .25, "Spill");
x_in=spillG.get_x_in(0);
y_in=spillG.get_y_in(0);
spillG.Set_XY(x_out-x_in+1., y_out-y_in);
x_out=spillG.get_x_out(3);
y_out=spillG.get_y_out(3);
spillG.Print();
triggerUnits1.push_back(spillG);

logic_unit dot0;
id=(int)triggerUnits1.size();
dot0.Set_Unit("dot", id, -1, -1, -1, 1, x_out+0.5, y_out-4., .25, "dot0");
dot0.Print();
triggerUnits1.push_back(dot0);

x_out=spillG.get_x_out(0);
y_out=spillG.get_y_out(0);

logic_unit fan_spill;
id=(int)triggerUnits1.size();
fan_spill.Set_Unit("LRS 429.4", id, 1, 3, 1, 1, 0., 0., .25, "Spill");
x_in=fan_spill.get_x_in(0);
y_in=fan_spill.get_y_in(0);
fan_spill.Set_XY(x_out-x_in+1., y_out-y_in);
x_out=fan_spill.get_x_out(3);
y_out=fan_spill.get_y_out(3);
fan_spill.Print();
triggerUnits1.push_back(fan_spill);

logic_unit spill_end_dl;
id=(int)triggerUnits1.size();
spill_end_dl.Set_Unit("LeCroy 222", id, 1, 5, 0, 1, 
                          spill_delay.get_X(), spill_delay.get_Y()-20., .25, "Delay 2");
x_out=spill_end_dl.get_x_out(0);
y_out=spill_end_dl.get_y_out(0);
spill_end_dl.Print();
triggerUnits1.push_back(spill_end_dl);

logic_unit spillE;
id=(int)triggerUnits1.size();
spillE.Set_Unit("LeCroy 222", id, 1, 5, 1, 1, 0., 0., .25, "Spill End");
x_in=spillE.get_x_in(0);
y_in=spillE.get_y_in(0);
spillE.Set_XY(x_out-x_in+1., y_out-y_in);
x_out=spillE.get_x_out(3);
y_out=spillE.get_y_out(3);
spillE.Print();
triggerUnits1.push_back(spillE);

logic_unit fan_spillE;
id=(int)triggerUnits1.size();
fan_spillE.Set_Unit("LRS 429.4", id, 1, 3, 2, 1, 0., 0., .25, "Spill End");
x_in=fan_spillE.get_x_in(0);
y_in=fan_spillE.get_y_in(0);
x_out=spillE.get_x_out(0);
y_out=spillE.get_y_out(0);
fan_spillE.Set_XY(x_out-x_in+1., y_out-y_in);
x_out=fan_spillE.get_x_out(3);
y_out=fan_spillE.get_y_out(3);
fan_spillE.Print();
triggerUnits1.push_back(fan_spillE);

logic_unit off_spill_dl;
id=(int)triggerUnits1.size();
off_spill_dl.Set_Unit("LeCroy 222", id, 1, 6, 0, 1, 
                          spill_end_dl.get_X(), spill_end_dl.get_Y()-20., .25, "Delay 3");
x_out=off_spill_dl.get_x_out(0);
y_out=off_spill_dl.get_y_out(0);
off_spill_dl.Print();
triggerUnits1.push_back(off_spill_dl);

logic_unit spillOff;
id=(int)triggerUnits1.size();
spillOff.Set_Unit("LeCroy 222", id, 1, 6, 1, 1, 0., 0., .25, "Off-Spill");
x_in=spillOff.get_x_in(0);
y_in=spillOff.get_y_in(0);
spillOff.Set_XY(x_out-x_in+6., y_out-y_in);
x_out=spillOff.get_x_out(3);
y_out=spillOff.get_y_out(3);
spillOff.Print();
triggerUnits1.push_back(spillOff);

logic_unit fan_spillOff;
id=(int)triggerUnits1.size();
fan_spillOff.Set_Unit("LRS 429.4", id, 1, 3, 3, 1, 0., 0., .25, "Off-Spill");
x_in=fan_spillOff.get_x_in(0);
y_in=fan_spillOff.get_y_in(0);
x_out=spillOff.get_x_out(0);
y_out=spillOff.get_y_out(0);
fan_spillOff.Set_XY(x_out-x_in+1., y_out-y_in);
x_out=fan_spillOff.get_x_out(3);
y_out=fan_spillOff.get_y_out(3);
fan_spillOff.Print();
triggerUnits1.push_back(fan_spillOff);

logic_unit dot1;
id=(int)triggerUnits1.size();
dot1.Set_Unit("dot", id, -1, -1, -1, 1,
                     spillOff.get_X(),
                     0.50*spillOff.get_y_out(0)+0.50*spillE.get_y_out(3), .25, "dot1");
dot1.Print();
triggerUnits1.push_back(dot1);

logic_unit dot2;
id=(int)triggerUnits1.size();
dot2.Set_Unit("dot", id, -1, -1, -1, 1,
                     0.5*(spillOff.get_X()+off_spill_dl.get_X()),
                     0.3*spillOff.get_y_out(0)+0.7*spillE.get_y_out(3), .25, "dot2");
dot2.Print();
triggerUnits1.push_back(dot2);



//===========================================================================

logic_unit in_Busy1;
id=(int)triggerUnits1.size();
in_Busy1.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 60., .25, "> Busy1");
x_out=in_Busy1.get_x_out(0);
y_out=in_Busy1.get_y_out(0);
in_Busy1.Print();
triggerUnits1.push_back(in_Busy1);

logic_unit fan_Busy1;
id=(int)triggerUnits1.size();
fan_Busy1.Set_Unit("LRS 429.4", id, 1, 2, 1, 1, 0., 0., .25, "Busy 1");
x_in=fan_Busy1.get_x_in(0);
y_in=fan_Busy1.get_y_in(0);
fan_Busy1.Set_XY(x_out-x_in+1., y_out-y_in);
fan_Busy1.Print();
triggerUnits1.push_back(fan_Busy1);

logic_unit in_Busy2;
id=(int)triggerUnits1.size();
in_Busy2.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., in_Busy1.get_Y()-12., .25, "> Busy2");
x_out=in_Busy2.get_x_out(0);
y_out=in_Busy2.get_y_out(0);
in_Busy2.Print();
triggerUnits1.push_back(in_Busy2);

logic_unit fan_Busy2;
id=(int)triggerUnits1.size();
fan_Busy2.Set_Unit("LRS 429.4", id, 1, 2, 2, 1, 0., 0., .25, "Busy 2");
x_in=fan_Busy2.get_x_in(0);
y_in=fan_Busy2.get_y_in(0);
fan_Busy2.Set_XY(x_out-x_in+1., y_out-y_in);
fan_Busy2.Print();
triggerUnits1.push_back(fan_Busy2);

logic_unit in_Run;
id=(int)triggerUnits1.size();
in_Run.Set_Unit("INPUT", id, -1, -1, -1, -1, 4., in_Busy2.get_Y()-12., .25, "> Run");
x_out=in_Run.get_x_out(0);
y_out=in_Run.get_y_out(0);
in_Run.Print();
triggerUnits1.push_back(in_Run);

logic_unit fan_Run;
id=(int)triggerUnits1.size();
fan_Run.Set_Unit("LRS 429.4", id, 1, 2, 0, 1, 0., 0., .25, "Run");
x_in=fan_Run.get_x_in(0);
y_in=fan_Run.get_y_in(0);
fan_Run.Set_XY(x_out-x_in+1., y_out-y_in);
x_out=fan_Run.get_x_out(4);
y_out=fan_Run.get_y_out(4);
fan_Run.Print();
triggerUnits1.push_back(fan_Run);

logic_unit fan_Block;
id=(int)triggerUnits1.size();
fan_Block.Set_Unit("LRS 429.4", id, 1, 2, 3, 1, 0., 0., .25, "Veto");
x_in=fan_Block.get_x_in(2);
y_in=fan_Block.get_y_in(2);
fan_Block.Set_XY(x_out-x_in+3., y_out-y_in);
fan_Block.Print();
triggerUnits1.push_back(fan_Block);

///=================================================================
logic_unit in_WideBeam;
id=(int)triggerUnits1.size();
in_WideBeam.Set_Unit("INPUT", id, -1, -1, -1, 1, 4.,  in_Busy2.get_Y()-24., .25, "> Wide");
x_out=in_WideBeam.get_x_out(0);
y_out=in_WideBeam.get_y_out(0);
in_WideBeam.Print();
triggerUnits1.push_back(in_WideBeam);

logic_unit fan_wide;
id=(int)triggerUnits1.size();
fan_wide.Set_Unit("LRS 429.4", id, 1, 3, 0, 0, 0., 0., .25, "Wide");
fan_wide.align_in_out(0, in_WideBeam, 0, 1.0, 0.0);
/*
x_in=fan_wide.get_x_in(0);
y_in=fan_wide.get_y_in(0);
fan_wide.Set_XY(x_out-x_in+1., y_out-y_in);
*/
fan_wide.Print();
triggerUnits1.push_back(fan_wide);





// output =======================================================================

logic_unit Veto;
id=(int)triggerUnits1.size();
Veto.Set_Unit("OUTPUT", id, -1, -1, -1, 1, 95., fan_Block.get_y_out(0), .25, "> Veto");
Veto.Print();
triggerUnits1.push_back(Veto);


logic_unit spill_Eout1;
id=(int)triggerUnits1.size();
spill_Eout1.Set_Unit("OUTPUT", id, -1, -1, -1, 1, 95., fan_spillE.get_y_out(0), .25, "> SpillEnd");
spill_Eout1.Print();
triggerUnits1.push_back(spill_Eout1);


logic_unit spill_Off1;
id=(int)triggerUnits1.size();
spill_Off1.Set_Unit("OUTPUT", id, -1, -1, -1, 1, 95., fan_spillOff.get_y_out(0), .25, "> Spill Off");
spill_Off1.Print();
triggerUnits1.push_back(spill_Off1);

logic_unit Random_IN;
id=(int)triggerUnits1.size();
Random_IN.Set_Unit("OUTPUT", id, -1, -1, -1, 1, 95., fan_spillOff.get_y_out(0)-20., .25, "> RndmIN");
Random_IN.Print();
triggerUnits1.push_back(Random_IN);

logic_unit Random_OUT;
id=(int)triggerUnits1.size();
Random_OUT.Set_Unit("OUTPUT", id, -1, -1, -1, 1, 95., fan_spillOff.get_y_out(0)-30., .25, "> RndmOut");
Random_OUT.Print();
triggerUnits1.push_back(Random_OUT);

logic_unit out_spill0;
id=(int)triggerUnits1.size();
out_spill0.Set_Unit("OUTPUT", id, -1, -1, -1, 1, 95., fan_spill.get_y_out(3), .25, "> Spill");
out_spill0.Print();
triggerUnits1.push_back(out_spill0);

logic_unit out_spillQ;
id=(int)triggerUnits1.size();
out_spillQ.Set_Unit("OUTPUT", id, -1, -1, -1, 1, 95., fan_spill.get_y_out(0), .25, "> Spill");
out_spillQ.Print();
triggerUnits1.push_back(out_spillQ);

logic_unit pre_spill1;
id=(int)triggerUnits1.size();
pre_spill1.Set_Unit("OUTPUT", id, -1, -1, -1, 1, 95., disc_spill1.get_y_out(0), .25, ">Pre-Spill");
pre_spill1.Print();
triggerUnits1.push_back(pre_spill1);

logic_unit pre_spill2;
id=(int)triggerUnits1.size();
pre_spill2.Set_Unit("OUTPUT", id, -1, -1, -1, 1, 95., disc_spill1.get_y_out(2), .25, ">Pre-Spill");
pre_spill2.Print();
triggerUnits1.push_back(pre_spill2);

logic_unit sos1;
id=(int)triggerUnits1.size();
sos1.Set_Unit("OUTPUT", id, -1, -1, -1, 1, 95., 2*pre_spill2.get_Y()-pre_spill1.get_Y(), .25, ">SoS");
sos1.Print();
triggerUnits1.push_back(sos1);

logic_unit sos2;
id=(int)triggerUnits1.size();
sos2.Set_Unit("OUTPUT", id, -1, -1, -1, 1, 95., 2*sos1.get_Y()-pre_spill2.get_Y(), .25, ">SoS");
sos2.Print();
triggerUnits1.push_back(sos2);



logic_unit out_wide;
id=(int)triggerUnits1.size();
out_wide.Set_Unit("OUTPUT", id, -1, -1, -1, 1, 95., fan_wide.get_y_out(0), .25, "> Wide");
out_wide.Print();
triggerUnits1.push_back(out_wide);

logic_unit out_narrow;
id=(int)triggerUnits1.size();
out_narrow.Set_Unit("OUTPUT", id, -1, -1, -1, 1, 95., fan_wide.get_y_out(4), .25, ">Narrow");
out_narrow.Print();
triggerUnits1.push_back(out_narrow);

//=====================================================================
// Trigger #2 (fast)
//=====================================================================

logic_unit in_SpillOff;
id=(int)triggerUnits2.size();
in_SpillOff.Set_Unit("INPUT", id, -1, -1, -1, -1, 4., 150., .25, "> SpillOut");
in_SpillOff.Print();
triggerUnits2.push_back(in_SpillOff);

logic_unit in_RndmIN;
id=(int)triggerUnits2.size();
in_RndmIN.Set_Unit("INPUT", id, -1, -1, -1, -1, 4., in_SpillOff.get_Y()-6., .25, "> RndmIN");
in_RndmIN.Print();
triggerUnits2.push_back(in_RndmIN);

logic_unit in_RndmOUT;
id=(int)triggerUnits2.size();
in_RndmOUT.Set_Unit("INPUT", id, -1, -1, -1, -1, 4., in_RndmIN.get_Y()-6., .25, "> RndmOUT");
in_RndmOUT.Print();
triggerUnits2.push_back(in_RndmOUT);

logic_unit in_Spill;
id=(int)triggerUnits2.size();
in_Spill.Set_Unit("INPUT", id, -1, -1, -1, -1, 4., in_RndmOUT.get_Y()-6., .25, "> Spill");
in_Spill.Print();
triggerUnits2.push_back(in_Spill);

logic_unit in_Veto;
id=(int)triggerUnits2.size();
in_Veto.Set_Unit("INPUT", id, -1, -1, -1, -1, 4., in_Spill.get_Y()-6., .25, "> Veto");
in_Veto.Print();
triggerUnits2.push_back(in_Veto);


//=================================================================
logic_unit in_Wide;
id=(int)triggerUnits2.size();
in_Wide.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 120., .25, "> Wide");
x_out=in_Wide.get_x_out(0);
y_out=in_Wide.get_y_out(0);
in_Wide.Print();
triggerUnits2.push_back(in_Wide);

logic_unit in_Narrow;
id=(int)triggerUnits2.size();
in_Narrow.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 113., .25, "> Narrow");
x_out=in_Narrow.get_x_out(0);
y_out=in_Narrow.get_y_out(0);
in_Narrow.Print();
triggerUnits2.push_back(in_Narrow);




//=================================================================
logic_unit in_s1;
id=(int)triggerUnits2.size();
in_s1.Set_Unit("INPUT", id, -1, -1, -1, 1, 4.,106., .25, "> S1");
x_out=in_s1.get_x_out(0);
y_out=in_s1.get_y_out(0);
in_s1.Print();
triggerUnits2.push_back(in_s1);

logic_unit fan_s1;
id=(int)triggerUnits2.size();
fan_s1.Set_Unit("LeCroy 428F", id, 2, 0, 0, 1, 0., 0., .25, "S1");
x_in=fan_s1.get_x_in(0);
y_in=fan_s1.get_y_in(0);
fan_s1.Set_XY(x_out-x_in+1., y_out-y_in);
x_out=fan_s1.get_x_out(1);
y_out=fan_s1.get_y_out(1);
fan_s1.Print();
triggerUnits2.push_back(fan_s1);

logic_unit discr_s1;
id=(int)triggerUnits2.size();
discr_s1.Set_Unit("LeCroy 825", id, 2, 3, 0, 1, 0., 0., .25, "S1");
x_in=discr_s1.get_x_in(0);
y_in=discr_s1.get_y_in(0);
discr_s1.Set_XY(x_out-x_in+1., y_out-y_in);
x_out1=discr_s1.get_x_out(1);
y_out1=discr_s1.get_y_out(1);
discr_s1.Print();
triggerUnits2.push_back(discr_s1);


//.....................................

logic_unit in_s2;
id=(int)triggerUnits2.size();
in_s2.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 94., .25, "> S2");
x_out=in_s2.get_x_out(0);
y_out=in_s2.get_y_out(0);
in_s2.Print();
triggerUnits2.push_back(in_s2);

logic_unit fan_s2;
id=(int)triggerUnits2.size();
fan_s2.Set_Unit("LeCroy 428F", id, 2, 0, 1, 1, 0., 0., .25, "S2");
x_in=fan_s2.get_x_in(0);
y_in=fan_s2.get_y_in(0);
fan_s2.Set_XY(x_out-x_in+1., y_out-y_in);
x_out=fan_s2.get_x_out(1);
y_out=fan_s2.get_y_out(1);
fan_s2.Print();
triggerUnits2.push_back(fan_s2);

logic_unit discr_s2;
id=(int)triggerUnits2.size();
discr_s2.Set_Unit("LeCroy 825", id, 2, 3, 1, 1, 0., 0., .25, "S2");
x_in=discr_s2.get_x_in(0);
y_in=discr_s2.get_y_in(0);
discr_s2.Set_XY(x_out-x_in+1., y_out-y_in);
x_out2=discr_s2.get_x_out(1);
y_out2=discr_s2.get_y_out(1);
discr_s2.Print();
triggerUnits2.push_back(discr_s2);

// S1xS2 coinsidence
logic_unit S12;
id=(int)triggerUnits2.size();
S12.Set_Unit("LeCroy 365AL", id, 2, 5, 0, 1, 0., 0., .25, "S1S2");
x_in=S12.get_x_in(1);
y_in=S12.get_y_in(1);
S12.Set_XY(x_out1-x_in+3., y_out2-y_in);
x_out1=S12.get_x_out(1);
y_out1=S12.get_y_out(1);
S12.Print();
triggerUnits2.push_back(S12);




//......................................
logic_unit in_s3;
id=(int)triggerUnits2.size();
in_s3.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 82., .25, "> S3");
x_out=in_s3.get_x_out(0);
y_out=in_s3.get_y_out(0);
in_s3.Print();
triggerUnits2.push_back(in_s3);

logic_unit fan_s3;
id=(int)triggerUnits2.size();
fan_s3.Set_Unit("LeCroy 428F", id, 2, 0, 2, 1, 0., 0., .25, "S3");
x_in=fan_s3.get_x_in(0);
y_in=fan_s3.get_y_in(0);
fan_s3.Set_XY(x_out-x_in+1., y_out-y_in);
x_out=fan_s3.get_x_out(1);
y_out=fan_s3.get_y_out(1);
fan_s3.Print();
triggerUnits2.push_back(fan_s3);

logic_unit discr_s3;
id=(int)triggerUnits2.size();
discr_s3.Set_Unit("LeCroy 825", id, 2, 3, 2, 1, 0., 0., .25, "S3");
x_in=discr_s3.get_x_in(0);
y_in=discr_s3.get_y_in(0);
discr_s3.Set_XY(x_out-x_in+1., y_out-y_in);
x_out3=discr_s3.get_x_out(1);
y_out3=discr_s3.get_y_out(1);
discr_s3.Print();
triggerUnits2.push_back(discr_s3);

// wide coinsidence S123
logic_unit S123;
id=(int)triggerUnits2.size();
S123.Set_Unit("LeCroy 365AL", id, 2, 5, 1, 1, 0., 0., .25, "S123");
x_in=S123.get_x_in(1);
y_in=S123.get_y_in(1);
S123.Set_XY(x_out1-x_in+2., y_out3-y_in);
x_out=S123.get_x_out(1);
y_out=S123.get_y_out(1);
S123.Print();
triggerUnits2.push_back(S123);

// wide trigger
logic_unit S123Wide;
id=(int)triggerUnits2.size();
S123Wide.Set_Unit("LeCroy 365AL", id, 2, 6, 1, 1, 0., 0., .25, "Wide");
x_in=S123Wide.get_x_in(1);
y_in=S123Wide.get_y_in(1);
S123Wide.Set_XY(x_out-x_in+5., y_out-y_in);
S123Wide.Print();
triggerUnits2.push_back(S123Wide);



//......................................
logic_unit in_s4;
id=(int)triggerUnits2.size();
in_s4.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 70., .25, "> S4");
x_out=in_s4.get_x_out(0);
y_out=in_s4.get_y_out(0);
in_s4.Print();
triggerUnits2.push_back(in_s4);

logic_unit fan_s4;
id=(int)triggerUnits2.size();
fan_s4.Set_Unit("LeCroy 428F", id, 2, 0, 3, 1, 0., 0., .25, "S4");
x_in=fan_s4.get_x_in(0);
y_in=fan_s4.get_y_in(0);
fan_s4.Set_XY(x_out-x_in+1., y_out-y_in);
x_out=fan_s4.get_x_out(1);
y_out=fan_s4.get_y_out(1);
fan_s4.Print();
triggerUnits2.push_back(fan_s4);

logic_unit discr_s4;
id=(int)triggerUnits2.size();
discr_s4.Set_Unit("LeCroy 825", id, 2, 3, 3, 1, 0., 0., .25, "S4");
x_in=discr_s4.get_x_in(0);
y_in=discr_s4.get_y_in(0);
discr_s4.Set_XY(x_out-x_in+1., y_out-y_in);
x_out4=discr_s4.get_x_out(1);
y_out4=discr_s4.get_y_out(1);
discr_s4.Print();
triggerUnits2.push_back(discr_s4);

// narrow trigger coinsidence S124
logic_unit S124;
id=(int)triggerUnits2.size();
S124.Set_Unit("LeCroy 365AL", id, 2, 6, 0, 1, 0., 0., .25, "S124");
x_in=S124.get_x_in(1);
y_in=S124.get_y_in(1);
S124.Set_XY(S123.get_X(), y_out4-y_in);
x_out=S124.get_x_out(1);
y_out=S124.get_y_out(1);
S124.Print();
triggerUnits2.push_back(S124);

// wide trigger
logic_unit S124Narrow;
id=(int)triggerUnits2.size();
S124Narrow.Set_Unit("LeCroy 365AL", id, 2, 7, 0, 1, 0., 0., .25, "Narrow");
x_in=S124Narrow.get_x_in(1);
y_in=S124Narrow.get_y_in(1);
S124Narrow.Set_XY(S123Wide.get_X(), y_out-y_in);
S124Narrow.Print();
triggerUnits2.push_back(S124Narrow);

// wide or narrow
logic_unit S12X;
id=(int)triggerUnits2.size();
S12X.Set_Unit("LRS 429.4", id, 2, 8, 0, 1, 0., 0., .25, "S12X");
x_out=S123Wide.get_x_out(1);
y_out=S123Wide.get_y_out(1);
x_in=S12X.get_x_in(0);
y_in=S12X.get_y_in(0);
S12X.Set_XY(x_out-x_in+5., y_out-y_in);
x_out=S12X.get_x_out(5);
y_out=S12X.get_y_out(5);
S12X.Print();
triggerUnits2.push_back(S12X);

// delay for self-veto
logic_unit sv_delay;
id=(int)platformUnits.size();
sv_delay.Set_Unit("Delay", id, -1, -1, -1, 1, 0., 0., .25, "??? ns");
x_in=sv_delay.get_x_in(0);
y_in=sv_delay.get_y_in(0);
sv_delay.Set_XY(x_out-x_in+1., y_out-y_in);
sv_delay.Print();
triggerUnits2.push_back(sv_delay);

// delay for s1 trigger timing
logic_unit s1_delay;
id=(int)platformUnits.size();
s1_delay.Set_Unit("Delay", id, -1, -1, -1, 1, 0., 0., .25, "??? ns");
x_in=s1_delay.get_x_in(0);
y_in=s1_delay.get_y_in(0);
s1_delay.Set_XY(discr_s1.get_x_out(0)-x_in+1., discr_s1.get_y_out(0)-y_in);
s1_delay.Print();
triggerUnits2.push_back(s1_delay);

// Beam Trigger
logic_unit BeamTrigger;
id=(int)triggerUnits2.size();
BeamTrigger.Set_Unit("LeCroy 365AL", id, 2, 7, 1, 1, 0., 0., .25, "Beam");
x_out=sv_delay.get_x_out(0);
y_out=sv_delay.get_y_out(0);
x_in=BeamTrigger.get_x_in(3);
y_in=BeamTrigger.get_y_in(3);
BeamTrigger.Set_XY(x_out-x_in+4., y_out-y_in);
BeamTrigger.Print();
triggerUnits2.push_back(BeamTrigger);


//
//
//
//......................................
logic_unit in_Halo;
id=(int)triggerUnits2.size();
in_Halo.Set_Unit("INPUT", id, -1, -1, -1, 1, 4.,  58., .25, "> Halo");
x_out=in_Halo.get_x_out(0);
y_out=in_Halo.get_y_out(0);
in_Halo.Print();
triggerUnits2.push_back(in_Halo);

logic_unit fan_halo;
id=(int)triggerUnits2.size();
fan_halo.Set_Unit("LeCroy 428F", id, 2, 2, 0, 1, 0., 0., .25, "Halo");
x_in=fan_halo.get_x_in(0);
y_in=fan_halo.get_y_in(0);
fan_halo.Set_XY(x_out-x_in+1., y_out-y_in);
fan_halo.Print();
triggerUnits2.push_back(fan_halo);

//..................................................
logic_unit in_L1;
id=(int)triggerUnits2.size();
in_L1.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 46., .25, "> Leak 1");
x_out=in_L1.get_x_out(0);
y_out=in_L1.get_y_out(0);
in_L1.Print();
triggerUnits2.push_back(in_L1);

logic_unit fan_L1;
id=(int)triggerUnits2.size();
fan_L1.Set_Unit("LeCroy 428F", id, 2, 1, 0, 1, 0., 0., .25, "Leak 1");
x_in=fan_L1.get_x_in(0);
y_in=fan_L1.get_y_in(0);
fan_L1.Set_XY(x_out-x_in+1., y_out-y_in);
fan_L1.Print();
triggerUnits2.push_back(fan_L1);

//.....................................
logic_unit in_L2;
id=(int)triggerUnits2.size();
in_L2.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 34., .25, "> Leak 2");
x_out=in_L2.get_x_out(0);
y_out=in_L2.get_y_out(0);
in_L2.Print();
triggerUnits2.push_back(in_L2);

logic_unit fan_L2;
id=(int)triggerUnits2.size();
fan_L2.Set_Unit("LeCroy 428F", id, 2, 1, 1, 1, 0., 0., .25, "Leak 2");
x_in=fan_L2.get_x_in(0);
y_in=fan_L2.get_y_in(0);
fan_L2.Set_XY(x_out-x_in+1., y_out-y_in);
fan_L2.Print();
triggerUnits2.push_back(fan_L2);



//.....................................
logic_unit in_Sum1;
id=(int)triggerUnits2.size();
in_Sum1.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 22., .25, "> Sum 1");
x_out=in_Sum1.get_x_out(0);
y_out=in_Sum1.get_y_out(0);
in_Sum1.Print();
triggerUnits2.push_back(in_Sum1);

logic_unit fan_Sum1;
id=(int)triggerUnits2.size();
fan_Sum1.Set_Unit("LeCroy 428F", id, 2, 1, 2, 1, 0., 0., .25, "Sum1");
x_in=fan_Sum1.get_x_in(0);
y_in=fan_Sum1.get_y_in(0);
fan_Sum1.Set_XY(x_out-x_in+1., y_out-y_in);
fan_Sum1.Print();
triggerUnits2.push_back(fan_Sum1);

//.....................................
logic_unit in_Sum2;
id=(int)triggerUnits2.size();
in_Sum2.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 10., .25, "> Sum 2");
x_out=in_Sum2.get_x_out(0);
y_out=in_Sum2.get_y_out(0);
in_Sum2.Print();
triggerUnits2.push_back(in_Sum2);

logic_unit fan_Sum2;
id=(int)triggerUnits2.size();
fan_Sum2.Set_Unit("LeCroy 428F", id, 2, 1, 3, 1, 0., 0., .25, "Sum2");
x_in=fan_Sum2.get_x_in(0);
y_in=fan_Sum2.get_y_in(0);
fan_Sum2.Set_XY(x_out-x_in+1., y_out-y_in);
fan_Sum2.Print();
triggerUnits2.push_back(fan_Sum2);

//.....................................
// output
logic_unit out_trig0;
id=(int)triggerUnits2.size();
out_trig0.Set_Unit("OUTPUT", id, -1, -1, -1, 1, 95., BeamTrigger.get_y_out(0), .25, "> Trig");
out_trig0.Print();
triggerUnits2.push_back(out_trig0);

// gate test
/*
logic_unit gate;
id=(int)triggerUnits1.size();
x_2=out_busy.get_X();
y_2=out_busy.get_Y();
gate.Set_Unit("LeCroy 222", id, 1, 11, 0, 1, 0.5*x_2, 0.5*y_2, .25, "Spill");
gate.Print();
triggerUnits1.push_back(gate);
*/

//==================================================================
Canvas1->Clear();
Canvas1->cd(0)->SetGrid(1);
gPad->SetTopMargin(0.03);
gPad->SetRightMargin(0.03);
gPad->SetBottomMargin(0.03);
gPad->SetLeftMargin(0.03);
//drawing1->DrawCopy();
drawing1->DrawCopy("A");
myLatex->SetTextSize(0.05);
myLatex->SetTextAlign(21);
myLatex->DrawLatex(50., 152., "Trigger 1 (slow)");

for (int iu=0; iu<(int)triggerUnits1.size(); iu++) {
  triggerUnits1.at(iu).Draw(1);
}
//==================================================================
myLatex->SetTextSize(0.018);
myLatex->SetTextAlign(21);
myLatex->DrawLatex(in_Run.get_X(),      in_Run.get_Y()+2.,      "Run C.");
myLatex->DrawLatex(in_WideBeam.get_X(), in_WideBeam.get_Y()+2., "Run C.");
myLatex->DrawLatex(out_spill0.get_X(),  out_spill0.get_Y()+2.,  "Trig.2");
myLatex->DrawLatex(out_wide.get_X(),    out_wide.get_Y()+2.,    "Trig.2");
myLatex->DrawLatex(out_narrow.get_X(),  out_narrow.get_Y()+2.,  "Trig.2");
myLatex->DrawLatex(in_beam1.get_X(),    in_beam1.get_Y()+2.2,   "Accel.");
myLatex->DrawLatex(in_beam2.get_X(),    in_beam2.get_Y()+2.2,   "Accel.");
myLatex->DrawLatex(in_Busy1.get_X(),    in_Busy1.get_Y()+2.,    "DAQ 1");
myLatex->DrawLatex(in_Busy2.get_X(),    in_Busy2.get_Y()+2.,    "DAQ 2");

myLatex->DrawLatex(pre_spill1.get_X(),   pre_spill1.get_Y()+2.,  "DAQ 1");
myLatex->DrawLatex(pre_spill2.get_X(),   pre_spill2.get_Y()+2.,  "DAQ 2");
myLatex->DrawLatex(pre_spill1.get_X(),   sos1.get_Y()+2.,        "DAQ 1");
myLatex->DrawLatex(pre_spill2.get_X(),   sos2.get_Y()+2.,        "DAQ 2");
myLatex->DrawLatex(spill_Eout1.get_X(),  spill_Eout1.get_Y()+2., "DAQ ?");
myLatex->DrawLatex(out_spillQ.get_X(),   out_spillQ.get_Y()+2.,  "DAQ ?");
myLatex->DrawLatex(spill_Off1.get_X(),   spill_Off1.get_Y()+2.,  "DAQ ?");
myLatex->DrawLatex(Random_IN.get_X(),    Random_IN.get_Y()+2.,   "?");
myLatex->DrawLatex(Random_OUT.get_X(),   Random_OUT.get_Y()+2.,  "?");
myLatex->DrawLatex(Veto.get_X(),         Veto.get_Y()+2.,        "Trig 2");

//==================================================================
in_beam1.   connect_out_in(0, level1,      0, 0.5, 1);
level1.     connect_out_in(0, disc_spill1, 0, 0.5, 1);
disc_spill1.connect_out_in(0, pre_spill1,  0, 0.5, 1);
disc_spill1.connect_out_in(1, pre_spill2,  0, 0.5, 1);

in_beam2.    connect_out_in(0, level2,      0, 0.50, 1);
level2.      connect_out_in(0, disc_spill2, 0, 0.50, 1);
disc_spill2. connect_out_in(2, fan_spill2,  0, 0.50, 1);
disc_spill2. connect_out_in(0, sos1,        0, 0.95, 1);
disc_spill2. connect_out_in(1, sos2,        0, 0.95, 1);
fan_spill2.  connect_out_in(2, spill_delay, 0, 0.95, 1);

spill_delay. connect_out_in(3, spillG,      0, 0.50, 1);
spillG.      connect_out_in(0, fan_spill,   0, 0.50, 1);
spillG.      connect_out_in(3, dot0,        0, 1.00, 1);
fan_spill.   connect_out_in(3, out_spill0,  0, 0.50, 1);
fan_spill.   connect_out_in(0, out_spillQ,  0, 0.50, 1);
dot0.        connect_out_in(0, spill_end_dl,0, 1.00, 1);

spill_end_dl.connect_out_in(3, spillE,      0, 0.50, 1);
spillE.      connect_out_in(0, fan_spillE,  0, 0.50, 1);
spillE.      connect_out_in(3, dot1,        0, 1.00, 1);
fan_spillE.  connect_out_in(0, spill_Eout1, 0, 1.00, 1);
dot1.        connect_out_in(0, off_spill_dl,0, 1.00, 1);

off_spill_dl.connect_out_in(3, spillOff,    0, 0.50, 1);
spillOff.    connect_out_in(0, fan_spillOff,0, 0.50, 1);
fan_spillOff.connect_out_in(0, spill_Off1,  0, 0.50, 1);

disc_spill1. connect_out_in(2, dot2,        0, 0.00, 1);
dot2.        connect_out_in(0, spillOff,    1, 1.00, 1);

in_Busy1.connect_out_in(0, fan_Busy1, 0, 0.5, 1);
in_Busy2.connect_out_in(0, fan_Busy2, 0, 0.5, 1);
in_Run.  connect_out_in(0, fan_Run,   0, 0.5, 1);

fan_Busy1.connect_out_in(0, fan_Block, 0, 0.9, 1);
fan_Busy2.connect_out_in(0, fan_Block, 1, 0.5, 1);
fan_Run.  connect_out_in(4, fan_Block, 2, 0.5, 1);
fan_Block.connect_out_in(0, Veto,      0, 0.5, 1);


in_WideBeam.connect_out_in(0, fan_wide, 0, 0.5, 1);
fan_wide.connect_out_in(0, out_wide, 0., 0.5, 1.);
fan_wide.connect_out_in(4, out_narrow, 0., 0.5, 1.);
//==================================================================
Canvas1->Update();
Canvas1->Print("trigger.ps");
//==================================================================
Canvas2->Clear();
Canvas2->cd(0)->SetGrid(1);
gPad->SetTopMargin(0.03);
gPad->SetRightMargin(0.03);
gPad->SetBottomMargin(0.03);
gPad->SetLeftMargin(0.03);
//drawing1->DrawCopy();
drawing1->DrawCopy("A");
myLatex->SetTextSize(0.05);
myLatex->SetTextAlign(21);
myLatex->DrawLatex(50., 152., "Trigger 2 (fast)");

for (int iu=0; iu<(int)triggerUnits2.size(); iu++) {
  triggerUnits2.at(iu).Draw(1);
}
myLatex->SetTextSize(0.015);
myLatex->SetTextAlign(21);
myLatex->DrawLatex(in_Spill.get_X(),     in_Spill.get_Y()+2.,       "Trig.1");
myLatex->DrawLatex(in_SpillOff.get_X(),  in_SpillOff.get_Y()+2.,    "Trig.1");
myLatex->DrawLatex(in_Veto.get_X(),      in_Veto.get_Y()+2.,        "Trig.1");
myLatex->DrawLatex(in_Wide.get_X(),      in_Wide.get_Y()+2.,        "Trig.1");
myLatex->DrawLatex(in_Narrow.get_X(),    in_Narrow.get_Y()+2.,      "Trig.1");
myLatex->DrawLatex(in_RndmOUT.get_X(),   in_RndmOUT.get_Y()+2.,     "Trig.1");
myLatex->DrawLatex(in_RndmIN.get_X(),    in_RndmIN.get_Y()+2.,      "Trig.1");

myLatex->DrawLatex(sv_delay.get_X(),     sv_delay.get_Y()+2.,       "Self-Veto");


//==================================================================
in_WideBeam.connect_out_in(0, fan_wide, 0, 0.5, 1);
//==================================================================
in_s1.connect_out_in(0, fan_s1, 0, 0.5, 1);
in_s2.connect_out_in(0, fan_s2, 0, 0.5, 1);
in_s3.connect_out_in(0, fan_s3, 0, 0.5, 1);
in_s4.connect_out_in(0, fan_s4, 0, 0.5, 1);
in_Halo.connect_out_in(0, fan_halo, 0, 0.5, 1);
in_L1  .connect_out_in(0, fan_L1, 0, 0.5, 1);
in_L2  .connect_out_in(0, fan_L2, 0, 0.5, 1);
in_Sum1.connect_out_in(0, fan_Sum1, 0, 0.5, 1);
in_Sum2.connect_out_in(0, fan_Sum2, 0, 0.5, 1);

fan_s1.connect_out_in(1, discr_s1, 0, 0.5, 1);
fan_s2.connect_out_in(1, discr_s2, 0, 0.5, 1);
fan_s3.connect_out_in(1, discr_s3, 0, 0.5, 1);
fan_s4.connect_out_in(1, discr_s4, 0, 0.5, 1);

discr_s1.connect_out_in(1, S12,      0, 0.5, 1);
discr_s1.connect_out_in(0, s1_delay, 0, 0.5, 1);
discr_s2.connect_out_in(1, S12,      1, 0.5, 1);

S12.connect_out_in(1, S123, 0, 0.9, 1);
discr_s3.connect_out_in(1, S123, 1, 0.6, 1);
S12.connect_out_in(2, S124, 0, 0.3, 1);
discr_s4.connect_out_in(1, S124, 1, 0.6, 1);

S123.   connect_out_in(1, S123Wide, 1, 0.5, 1);
in_Wide.connect_out_in(0, S123Wide, 0, 1.0, 1);

S124.     connect_out_in(1, S124Narrow, 1, 0.50, 1);
in_Narrow.connect_out_in(0, S124Narrow, 0, 0.96, 1);

S123Wide.  connect_out_in(1, S12X, 0, 0.96, 1);
S124Narrow.connect_out_in(1, S12X, 1, 0.50, 1);

S12X.      connect_out_in(5, sv_delay,     0, 0.50, 1);
in_Spill.  connect_out_in(0, BeamTrigger,  0, 1.00, 1);
s1_delay.  connect_out_in(0, BeamTrigger,  1, 0.98, 1);
S12X.      connect_out_in(0, BeamTrigger,  2, 0.85, 1);
sv_delay.  connect_out_in(0, BeamTrigger,  3, 0.50, 1);
in_Veto.   connect_out_in(0, BeamTrigger,  4, 0.95, 1);

BeamTrigger.connect_out_in(0,  out_trig0, 0, 0.5, 1);
//==================================================================
Canvas2->Update();
Canvas2->Print("trigger.ps");
//==================================================================
//
//
//
Canvas3->Clear();
Canvas3->Divide(1, 3);
Canvas3->cd(1)->SetGrid(1);
gPad->SetTopMargin(0.03);
gPad->SetRightMargin(0.03);
gPad->SetBottomMargin(0.03);
gPad->SetLeftMargin(0.03);
drawing2->DrawCopy("A");
myLatex->SetTextSize(0.05);
myLatex->DrawLatex(50., 162., "Beam Area Crate");
for (int i=0; i<12; i++) {
  myModule->DrawBox(10.*i,    0., 10.*i+10., 160.);
  myLine->DrawLine(10.*i,     0., 10.*i+10.,   0.);
  myLine->DrawLine(10.*i,   160., 10.*i+10., 160.);
  myLine->DrawLine(10.*i,   160., 10.*i+10., 160.);
  myLine->DrawLine(10.*i,     0., 10.*i,     160.);
  myLine->DrawLine(10.*i+10., 0., 10.*i+10., 160.);
}
nDraw=(int) platformUnits.size();
for (int iu=0; iu<nDraw; iu++) {
  platformUnits.at(iu).DrawInCrate(0, 0);
}
Canvas3->Update();


Canvas3->cd(2)->SetGrid(1);
gPad->SetTopMargin(0.03);
gPad->SetRightMargin(0.03);
gPad->SetBottomMargin(0.03);
gPad->SetLeftMargin(0.03);
drawing3->DrawCopy("A");
myLatex->DrawLatex(50., 162., "Trigger Crate 1 (slow)");
for (int i=0; i<12; i++) {
  myModule->DrawBox(10.*i, 0., 10.*i+10., 160.);
  myLine->DrawLine(10.*i,     0., 10.*i+10.,   0.);
  myLine->DrawLine(10.*i,   160., 10.*i+10., 160.);
  myLine->DrawLine(10.*i,   160., 10.*i+10., 160.);
  myLine->DrawLine(10.*i,     0., 10.*i,     160.);
  myLine->DrawLine(10.*i+10., 0., 10.*i+10., 160.);
}
Canvas3->Update();

Canvas3->cd(3)->SetGrid(1);
gPad->SetTopMargin(0.03);
gPad->SetRightMargin(0.03);
gPad->SetBottomMargin(0.03);
gPad->SetLeftMargin(0.03);
drawing4->DrawCopy("A");
myLatex->DrawLatex(50., 162., "Trigger Crate 2 (fast)");
for (int i=0; i<12; i++) {
  myModule->DrawBox(10.*i, 0., 10.*i+10., 160.);
  myLine->DrawLine(10.*i,     0., 10.*i+10.,   0.);
  myLine->DrawLine(10.*i,   160., 10.*i+10., 160.);
  myLine->DrawLine(10.*i,   160., 10.*i+10., 160.);
  myLine->DrawLine(10.*i,     0., 10.*i,     160.);
  myLine->DrawLine(10.*i+10., 0., 10.*i+10., 160.);
}
Canvas3->Update();

for (int iu=0; iu<(int)triggerUnits1.size(); iu++) {
  int iDraw=0;
  int crate=triggerUnits1.at(iu).get_crate();
  if (crate==-1) continue;
  Canvas3->cd(crate+1);
  if (triggerUnits1.at(iu).get_type()==7) iDraw=0;
  triggerUnits1.at(iu).DrawInCrate(crate, iDraw);
}
for (int iu=0; iu<(int)triggerUnits2.size(); iu++) {
  int iDraw=0;
  int crate=triggerUnits2.at(iu).get_crate();
  if (crate==-1) continue;
  Canvas3->cd(crate+1);
  if (triggerUnits2.at(iu).get_type()==7) iDraw=0;
  triggerUnits2.at(iu).DrawInCrate(crate, iDraw);
}

Canvas3->Update();
Canvas3->Print("trigger.ps)");


}