#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=30.;
    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("Halo");
    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") { // Octal Risetime compensated discr.
    logic_type=1;
    Xsize=10.;
    Ysize=20.;
    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=30.;
    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=60.;
    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=120.;
    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");
    }
//==========================================
//  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 {
    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==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"
} 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==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/4.;
  y=htot-h*(unit+0.5);

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

} else if (logic_type==2) { // analog FAN-IN FAN-OUT
  sprintf(text, "A SUM");
  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) { // Dual Gate
  sprintf(text, "TTL-NIM");
  h=htot/16.;
  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);
}
//===========================================================
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;}
//===========================================================
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 trigger20210527() {
//===========================

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_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",             1200, 0, 800, 1200);
TCanvas* Canvas1 = new TCanvas("Canvas1", "Barracks",             2000, 0, 800, 1200);
TCanvas* Canvas2 = new TCanvas("Canvas2", "Crates2",              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, "Busy");
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, "Busy >");
out_busy.Print();
platformUnits.push_back(out_busy);






//=====================================
myLatex->SetTextAlign(21);

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->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);

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

logic_unit in_beam1;
id=(int)triggerUnits1.size();
in_beam1.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 145., .35, "> Spill 1");
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, "Spill 1");
x_in=level1.get_x_in(0);
y_in=level1.get_y_in(0);
level1.Set_XY(x_out-x_in+1., y_out-y_in);
level1.Print();
triggerUnits1.push_back(level1);

logic_unit in_beam2;
id=(int)triggerUnits1.size();
in_beam2.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 137., .35, "> Spill 2");
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, "Spill 2");
x_in=level2.get_x_in(0);
y_in=level2.get_y_in(0);
level2.Set_XY(x_out-x_in+1., y_out-y_in);
level2.Print();
triggerUnits1.push_back(level2);

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

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

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

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

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

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

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

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

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

logic_unit in_Busy1;
id=(int)triggerUnits1.size();
in_Busy1.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 57., .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 in_Busy2;
id=(int)triggerUnits1.size();
in_Busy2.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 49., .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 in_Run;
id=(int)triggerUnits1.size();
in_Run.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 41., .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 in_WideBeam;
id=(int)triggerUnits1.size();
in_WideBeam.Set_Unit("INPUT", id, -1, -1, -1, 1, 4., 33., .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);


// output
logic_unit out_trig0;
id=(int)triggerUnits1.size();
out_trig0.Set_Unit("OUTPUT", id, -1, -1, -1, 1, x_2, 145., .25, "> Trig");
out_trig0.Print();
triggerUnits1.push_back(out_trig0);

// output
logic_unit out_spill0;
id=(int)triggerUnits1.size();
out_spill0.Set_Unit("OUTPUT", id, -1, -1, -1, 1, x_2, 137., .25, "> Spill");
out_spill0.Print();
triggerUnits1.push_back(out_spill0);

// 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("A");
myLatex->DrawLatex(50., 152., "Trigger");

for (int iu=0; iu<(int)triggerUnits1.size(); iu++) {
  triggerUnits1.at(iu).Draw(1);
}
//==================================================================
in_beam1.connect_out_in(0, level1, 0, 0.5, 1);
in_beam2.connect_out_in(0, level2, 0, 0.5, 1);
//==================================================================
Canvas1->Update();
Canvas1->Print("trigger.ps");
//==================================================================
//
//
//
Canvas2->Clear();
Canvas2->Divide(1, 3);
Canvas2->cd(1)->SetGrid(1);
gPad->SetTopMargin(0.03);
gPad->SetRightMargin(0.03);
gPad->SetBottomMargin(0.03);
gPad->SetLeftMargin(0.03);
drawing2->DrawCopy("A");
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);
}


Canvas2->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");
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.);
}
for (int iu=0; iu<(int)triggerUnits1.size(); iu++) {
  int iDraw=0;
  if (triggerUnits1.at(iu).get_type()==7) iDraw=0;
  triggerUnits1.at(iu).DrawInCrate(1, iDraw);
}

Canvas2->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");
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.);
}

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


}