/**
* Execute application
*/
void gridpack::dynamic_simulation::DSApp::execute(int argc, char** argv)
{
gridpack::utility::CoarseTimer *timer =
gridpack::utility::CoarseTimer::instance();
int t_total = timer->createCategory("Total Application");
timer->start(t_total);
gridpack::parallel::Communicator world;
boost::shared_ptr<DSNetwork> network(new DSNetwork(world));
int t_setup = timer->createCategory("Read in Data");
timer->start(t_setup);
// read configuration file
gridpack::utility::Configuration *config = gridpack::utility::Configuration::configuration();
if (argc >= 2 && argv[1] != NULL) {
char inputfile[256];
sprintf(inputfile,"%s",argv[1]);
config->open(inputfile,world);
} else {
config->open("input.xml",world);
}
gridpack::utility::Configuration::CursorPtr cursor;
cursor = config->getCursor("Configuration.Dynamic_simulation");
std::string filename = cursor->get("networkConfiguration",
"No network configuration specified");
double sim_time = cursor->get("simulationTime",0.0);
if (sim_time == 0.0) {
// TODO: some kind of error
}
double time_step = cursor->get("timeStep",0.0);
if (time_step == 0.0) {
// TODO: some kind of error
}
// Read in information about fault events and store them in internal data
// structure
cursor = config->getCursor("Configuration.Dynamic_simulation.faultEvents");
gridpack::utility::Configuration::ChildCursors events;
if (cursor) cursor->children(events);
std::vector<gridpack::dynamic_simulation::DSBranch::Event>
faults = setFaultEvents(events);
// load input file
gridpack::parser::PTI23_parser<DSNetwork> parser(network);
parser.parse(filename.c_str());
cursor = config->getCursor("Configuration.Dynamic_simulation");
filename = cursor->get("generatorParameters","");
timer->stop(t_setup);
int t_part = timer->createCategory("Partition Network");
timer->start(t_part);
// partition network
network->partition();
timer->stop(t_part);
if (filename.size() > 0) parser.externalParse(filename.c_str());
// Create serial IO object to export data from buses or branches
gridpack::serial_io::SerialBusIO<DSNetwork> busIO(2048, network);
gridpack::serial_io::SerialBranchIO<DSNetwork> branchIO(128, network);
char ioBuf[128];
int t_config = timer->createCategory("Configure Network");
timer->start(t_config);
// create factory
gridpack::dynamic_simulation::DSFactory factory(network);
factory.load();
// set network components using factory
factory.setComponents();
timer->stop(t_config);
// set YBus components so that you can create Y matrix
factory.setYBus();
if (!factory.checkGen()) {
busIO.header("Missing generators on at least one processor\n");
return;
}
int t_matset = timer->createCategory("Matrix Setup");
timer->start(t_matset);
factory.setMode(YBUS);
gridpack::mapper::FullMatrixMap<DSNetwork> ybusMap(network);
timer->stop(t_matset);
int t_trans = timer->createCategory("Matrix Transpose");
// Construct matrix Y_a using extracted xd and ra from gen data,
// and construct its diagonal matrix diagY_a
timer->start(t_matset);
factory.setMode(YA);
gridpack::mapper::FullMatrixMap<DSNetwork> yaMap(network);
boost::shared_ptr<gridpack::math::Matrix> diagY_a = yaMap.mapToMatrix();
///busIO.header("\n=== diagY_a: ============\n");
///diagY_a->print();
// Convert diagY_a from sparse matrix to dense matrix Y_a so that SuperLU_DIST can solve
gridpack::math::MatrixStorageType denseType = gridpack::math::Dense;
boost::shared_ptr<gridpack::math::Matrix> Y_a(gridpack::math::storageType(*diagY_a, denseType));
timer->stop(t_matset);
// Construct matrix Ymod: Ymod = diagY_a * permTrans
int t_matmul = timer->createCategory("Matrix Multiply");
// Form matrix Y_b: Y_b(1:ngen, jg) = -Ymod, where jg represents the
// corresponding index sets of buses that the generators are connected to.
// Then construct Y_b's transposed matrix Y_c: Y_c = Y_b'
// This two steps can be done by using a P matrix to get Y_c directly.
timer->start(t_matset);
factory.setMode(YC);
gridpack::mapper::FullMatrixMap<DSNetwork> cMap(network);
boost::shared_ptr<gridpack::math::Matrix> Y_cDense = cMap.mapToMatrix(true);
factory.setMode(YB);
gridpack::mapper::FullMatrixMap<DSNetwork> bMap(network);
boost::shared_ptr<gridpack::math::Matrix> Y_b = bMap.mapToMatrix();
timer->stop(t_matset);
///busIO.header("\n=== Y_b: ============\n");
///Y_b->print();
timer->start(t_matset);
factory.setMode(updateYbus);
boost::shared_ptr<gridpack::math::Matrix> prefy11ybus = ybusMap.mapToMatrix();
timer->stop(t_matset);
///branchIO.header("\n=== prefy11ybus: ============\n");
///prefy11ybus->print();
// Solve linear equations of ybus * X = Y_c
//gridpack::math::LinearSolver solver1(*prefy11ybus);
//solver1.configure(cursor);
int t_solve = timer->createCategory("Solve Linear Equation");
timer->start(t_solve);
gridpack::math::LinearMatrixSolver solver1(*prefy11ybus);
boost::shared_ptr<gridpack::math::Matrix> prefy11X(solver1.solve(*Y_cDense));
timer->stop(t_solve);
///branchIO.header("\n=== prefy11X: ============\n");
///prefy11X->print();
//-----------------------------------------------------------------------
// Compute prefy11
//-----------------------------------------------------------------------
// Form reduced admittance matrix prefy11: prefy11 = Y_b * X
timer->start(t_matmul);
boost::shared_ptr<gridpack::math::Matrix> prefy11(multiply(*Y_b, *prefy11X));
timer->stop(t_matmul);
// Update prefy11: prefy11 = Y_a + prefy11
prefy11->add(*Y_a);
///branchIO.header("\n=== Reduced Ybus: prefy11: ============\n");
///prefy11->print();
//-----------------------------------------------------------------------
// Compute fy11
// Update ybus values at fault stage
//-----------------------------------------------------------------------
// Read the switch info from faults Event from input.xml
int sw2_2 = faults[0].from_idx - 1;
int sw3_2 = faults[0].to_idx - 1;
boost::shared_ptr<gridpack::math::Matrix> fy11ybus(prefy11ybus->clone());
///branchIO.header("\n=== fy11ybus(original): ============\n");
///fy11ybus->print();
gridpack::ComplexType x(0.0, -1e7);
timer->start(t_matset);
factory.setEvent(faults[0]);
factory.setMode(onFY);
ybusMap.overwriteMatrix(fy11ybus);
timer->stop(t_matset);
///branchIO.header("\n=== fy11ybus: ============\n");
///fy11ybus->print();
// Solve linear equations of fy11ybus * X = Y_c
timer->start(t_solve);
gridpack::math::LinearMatrixSolver solver2(*fy11ybus);
boost::shared_ptr<gridpack::math::Matrix> fy11X(solver2.solve(*Y_cDense));
timer->stop(t_solve);
///branchIO.header("\n=== fy11X: ============\n");
///fy11X->print();
// Form reduced admittance matrix fy11: fy11 = Y_b * X
timer->start(t_matmul);
boost::shared_ptr<gridpack::math::Matrix> fy11(multiply(*Y_b, *fy11X));
timer->stop(t_matmul);
// Update fy11: fy11 = Y_a + fy11
fy11->add(*Y_a);
///branchIO.header("\n=== Reduced Ybus: fy11: ============\n");
///fy11->print();
//-----------------------------------------------------------------------
// Compute posfy11
// Update ybus values at clear fault stage
//-----------------------------------------------------------------------
// Get the updating factor for posfy11 stage ybus
timer->start(t_matset);
boost::shared_ptr<gridpack::math::Matrix> posfy11ybus(prefy11ybus->clone());
timer->stop(t_matset);
///branchIO.header("\n=== posfy11ybus (original): ============\n");
///posfy11ybus->print();
timer->start(t_matset);
factory.setMode(posFY);
ybusMap.incrementMatrix(posfy11ybus);
timer->stop(t_matset);
///branchIO.header("\n=== posfy11ybus: ============\n");
///posfy11ybus->print();
// Solve linear equations of posfy11ybus * X = Y_c
timer->start(t_solve);
gridpack::math::LinearMatrixSolver solver3(*posfy11ybus);
boost::shared_ptr<gridpack::math::Matrix> posfy11X(solver3.solve(*Y_cDense));
timer->stop(t_solve);
///branchIO.header("\n=== posfy11X: ============\n");
///posfy11X->print();
// Form reduced admittance matrix posfy11: posfy11 = Y_b * X
timer->start(t_matmul);
boost::shared_ptr<gridpack::math::Matrix> posfy11(multiply(*Y_b, *posfy11X));
timer->stop(t_matmul);
// Update posfy11: posfy11 = Y_a + posfy11
posfy11->add(*Y_a);
///branchIO.header("\n=== Reduced Ybus: posfy11: ============\n");
///posfy11->print();
//-----------------------------------------------------------------------
// Integration implementation (Modified Euler Method)
//-----------------------------------------------------------------------
factory.setDSParams();
factory.setMode(Eprime0);
gridpack::mapper::BusVectorMap<DSNetwork> Emap(network);
boost::shared_ptr<gridpack::math::Vector> eprime_s0 = Emap.mapToVector();
boost::shared_ptr<gridpack::math::Vector> eprime_s1(eprime_s0->clone());
boost::shared_ptr<gridpack::math::Vector> curr(eprime_s0->clone());
timer->start(t_trans);
boost::shared_ptr<gridpack::math::Matrix> trans_prefy11(transpose(*prefy11));
boost::shared_ptr<gridpack::math::Matrix> trans_fy11(transpose(*fy11));
boost::shared_ptr<gridpack::math::Matrix> trans_posfy11(transpose(*posfy11));
timer->stop(t_trans);
// Simulation related variables
int simu_k;
int t_step[20];
double t_width[20];
int flagF;
int S_Steps;
int last_S_Steps;
int steps3, steps2, steps1;
double h_sol1, h_sol2;
int flagF1, flagF2;
int I_Steps;
const double sysFreq = 60.0;
double pi = 4.0*atan(1.0);
const double basrad = 2.0 * pi * sysFreq;
gridpack::ComplexType jay(0.0, 1.0);
// switch info is set up here
int nswtch = 4;
static double sw1[4];
static double sw7[4];
sw1[0] = 0.0;
sw1[1] = faults[0].start;
sw1[2] = faults[0].end;
sw1[3] = sim_time;
sw7[0] = time_step;
sw7[1] = faults[0].step;
sw7[2] = time_step;
sw7[3] = time_step;
simu_k = 0;
for (int i = 0; i < nswtch-1; i++) {
t_step[i] = (int) ((sw1[i+1] -sw1[i]) / sw7[i]);
t_width[i] = (sw1[i+1] - sw1[i]) / t_step[i];
simu_k += t_step[i];
}
simu_k++;
steps3 = t_step[0] + t_step[1] + t_step[2] - 1;
steps2 = t_step[0] + t_step[1] - 1;
steps1 = t_step[0] - 1;
h_sol1 = t_width[0];
h_sol2 = h_sol1;
flagF1 = 0;
flagF2 = 0;
S_Steps = 1;
last_S_Steps = -1;
for (I_Steps = 0; I_Steps < simu_k+1; I_Steps++) {
if (I_Steps < steps1) {
S_Steps = I_Steps;
flagF1 = 0;
flagF2 = 0;
} else if (I_Steps == steps1) {
S_Steps = I_Steps;
flagF1 = 0;
flagF2 = 1;
} else if (I_Steps == steps1+1) {
S_Steps = I_Steps;
flagF1 = 1;
flagF2 = 1;
} else if ((I_Steps>steps1+1) && (I_Steps<steps2+1)) {
S_Steps = I_Steps - 1;
flagF1 = 1;
flagF2 = 1;
} else if (I_Steps==steps2+1) {
S_Steps = I_Steps - 1;
flagF1 = 1;
flagF2 = 2;
} else if (I_Steps==steps2+2) {
S_Steps = I_Steps - 1;
flagF1 = 2;
flagF2 = 2;
} else if (I_Steps>steps2+2) {
S_Steps = I_Steps - 2;
flagF1 = 2;
flagF2 = 2;
}
if (I_Steps !=0 && last_S_Steps != S_Steps) {
factory.initDSStep(false);
} else {
factory.initDSStep(true);
}
factory.setMode(Eprime0);
Emap.mapToVector(eprime_s0);
// ---------- CALL i_simu_innerloop(k,S_Steps,flagF1): ----------
int t_trnsmul = timer->createCategory("Transpose Multiply");
timer->start(t_trnsmul);
if (flagF1 == 0) {
curr.reset(multiply(*trans_prefy11, *eprime_s0)); //MatMultTranspose(prefy11, eprime_s0, curr);
//transposeMultiply(*prefy11,*eprime_s0,*curr);
} else if (flagF1 == 1) {
curr.reset(multiply(*trans_fy11, *eprime_s0)); //MatMultTranspose(fy11, eprime_s0, curr);
//transposeMultiply(*fy11,*eprime_s0,*curr);
} else if (flagF1 == 2) {
curr.reset(multiply(*trans_posfy11, *eprime_s0)); //MatMultTranspose(posfy11, eprime_s0, curr);
//transposeMultiply(*posfy11,*eprime_s0,*curr);
}
timer->stop(t_trnsmul);
factory.setMode(Current);
Emap.mapToBus(curr);
factory.predDSStep(h_sol1);
factory.setMode(Eprime1);
Emap.mapToVector(eprime_s1);
// ---------- CALL i_simu_innerloop2(k,S_Steps+1,flagF2): ----------
timer->start(t_trnsmul);
if (flagF2 == 0) {
curr.reset(multiply(*trans_prefy11, *eprime_s1)); //MatMultTranspose(prefy11, eprime_s1, curr);
//transposeMultiply(*prefy11,*eprime_s1,*curr);
} else if (flagF2 == 1) {
curr.reset(multiply(*trans_fy11, *eprime_s1)); //MatMultTranspose(fy11, eprime_s1, curr);
//transposeMultiply(*fy11,*eprime_s1,*curr);
} else if (flagF2 == 2) {
curr.reset(multiply(*trans_posfy11, *eprime_s1)); //MatMultTranspose(posfy11, eprime_s1, curr);
//transposeMultiply(*posfy11,*eprime_s1,*curr);
}
timer->stop(t_trnsmul);
factory.setMode(Current);
Emap.mapToBus(curr);
factory.corrDSStep(h_sol2);
// Print to screen
if (last_S_Steps != S_Steps) {
//sprintf(ioBuf, "\n========================S_Steps = %d=========================\n", S_Steps);
//busIO.header(ioBuf);
//mac_ang_s0->print();
//mac_spd_s0->print();
//pmech->print();
//pelect->print();
//sprintf(ioBuf, "========================End of S_Steps = %d=========================\n\n", S_Steps);
//busIO.header(ioBuf);
}
if (I_Steps == simu_k) {
sprintf(ioBuf, "\n========================S_Steps = %d=========================\n",
S_Steps+1);
busIO.header(ioBuf);
sprintf(ioBuf, "\n Bus ID Generator ID"
" mac_ang mac_spd mech elect\n\n");
busIO.header(ioBuf);
//mac_ang_s1->print();
//mac_spd_s1->print();
//pmech->print();
//pelect->print();
busIO.write();
sprintf(ioBuf, "\n========================End of S_Steps = %d=========================\n\n",
S_Steps+1);
busIO.header(ioBuf);
} // End of Print to screen
last_S_Steps = S_Steps;
}
timer->stop(t_total);
timer->dump();
}
void gridpack::dynamic_simulation_r::DSAppModule::solve(
gridpack::dynamic_simulation_r::DSBranch::Event fault)
{
gridpack::utility::CoarseTimer *timer =
gridpack::utility::CoarseTimer::instance();
int t_total = timer->createCategory("Dynamic Simulation: Total Application");
#if 0
timer->start(t_total);
int t_matset = timer->createCategory("Dynamic Simulation: Matrix Setup");
timer->start(t_matset);
p_factory->setMode(YBUS);
gridpack::mapper::FullMatrixMap<DSNetwork> ybusMap(p_network);
boost::shared_ptr<gridpack::math::Matrix> orgYbus = ybusMap.mapToMatrix();
///p_branchIO.header("\n=== orginal ybus: ============\n");
///orgYbus->print();
// Form constant impedance load admittance yl for all buses and add it to
// system Y matrix: ybus = ybus + yl
p_factory->setMode(YL);
boost::shared_ptr<gridpack::math::Matrix> ybus = ybusMap.mapToMatrix();
///p_branchIO.header("\n=== ybus after added yl: ============\n");
///ybus->print();
// Construct permutation matrix perm by checking for multiple generators at a bus
p_factory->setMode(PERM);
gridpack::mapper::FullMatrixMap<DSNetwork> permMap(p_network);
boost::shared_ptr<gridpack::math::Matrix> perm = permMap.mapToMatrix();
timer->stop(t_matset);
///p_busIO->header("\n=== perm: ============\n");
///perm->print();
// Form a transposed matrix of perm
int t_trans = timer->createCategory("Dynamic Simulation: Matrix Transpose");
timer->start(t_trans);
boost::shared_ptr<gridpack::math::Matrix> permTrans(transpose(*perm));
timer->stop(t_trans);
///p_busIO->header("\n=== permTrans: ============\n");
///permTrans->print();
// Construct matrix Y_a using extracted xd and ra from gen data,
// and construct its diagonal matrix diagY_a
timer->start(t_matset);
p_factory->setMode(YA);
gridpack::mapper::FullMatrixMap<DSNetwork> yaMap(p_network);
boost::shared_ptr<gridpack::math::Matrix> diagY_a = yaMap.mapToMatrix();
///p_busIO->header("\n=== diagY_a: ============\n");
///diagY_a->print();
// Convert diagY_a from sparse matrix to dense matrix Y_a so that SuperLU_DIST can solve
gridpack::math::MatrixStorageType denseType = gridpack::math::Dense;
boost::shared_ptr<gridpack::math::Matrix> Y_a(gridpack::math::storageType(*diagY_a, denseType));
timer->stop(t_matset);
// Construct matrix Ymod: Ymod = diagY_a * permTrans
int t_matmul = timer->createCategory("Dynamic Simulation: Matrix Multiply");
timer->start(t_matmul);
boost::shared_ptr<gridpack::math::Matrix> Ymod(multiply(*diagY_a, *permTrans));
timer->stop(t_matmul);
///p_busIO->header("\n=== Ymod: ============\n");
///Ymod->print();
// Form matrix Y_b: Y_b(1:ngen, jg) = -Ymod, where jg represents the
// corresponding index sets of buses that the generators are connected to.
// Then construct Y_b's transposed matrix Y_c: Y_c = Y_b'
// This two steps can be done by using a P matrix to get Y_c directly.
timer->start(t_matset);
p_factory->setMode(PMatrix);
gridpack::mapper::FullMatrixMap<DSNetwork> pMap(p_network);
boost::shared_ptr<gridpack::math::Matrix> P = pMap.mapToMatrix();
///p_busIO->header("\n=== P: ============\n");
///P->print();
p_factory->setMode(YC);
gridpack::mapper::FullMatrixMap<DSNetwork> cMap(p_network);
boost::shared_ptr<gridpack::math::Matrix> Y_c = cMap.mapToMatrix();
Y_c->scale(-1.0);
///p_busIO->header("\n=== Y_c: ============\n");
///Y_c->print();
p_factory->setMode(YB);
gridpack::mapper::FullMatrixMap<DSNetwork> bMap(p_network);
boost::shared_ptr<gridpack::math::Matrix> Y_b = bMap.mapToMatrix();
timer->stop(t_matset);
///p_busIO->header("\n=== Y_b: ============\n");
///Y_b->print();
Y_c->scale(-1.0); // scale Y_c by -1.0 for linear solving
// Convert Y_c from sparse matrix to dense matrix Y_cDense so that SuperLU_DIST can solve
//gridpack::math::Matrix::StorageType denseType = gridpack::math::Matrix::Dense;
timer->start(t_matset);
boost::shared_ptr<gridpack::math::Matrix> Y_cDense(gridpack::math::storageType(*Y_c, denseType));
// Form matrix permYmod
p_factory->setMode(permYMOD);
gridpack::mapper::FullMatrixMap<DSNetwork> pymMap(p_network);
boost::shared_ptr<gridpack::math::Matrix> permYmod= pymMap.mapToMatrix();
///p_busIO->header("\n=== permYmod: ============\n");
///permYmod->print();
// Update ybus: ybus = ybus+permYmod (different dimension) => prefy11ybus
p_factory->setMode(updateYbus);
boost::shared_ptr<gridpack::math::Vector> vPermYmod(diagonal(*permYmod));
///p_busIO->header("\n=== vPermYmod: ============\n");
///vPermYmod->print();
gridpack::mapper::BusVectorMap<DSNetwork> permYmodMap(p_network);
permYmodMap.mapToBus(vPermYmod);
boost::shared_ptr<gridpack::math::Matrix> prefy11ybus = ybusMap.mapToMatrix();
timer->stop(t_matset);
///p_branchIO.header("\n=== prefy11ybus: ============\n");
///prefy11ybus->print();
// Solve linear equations of ybus * X = Y_c
//gridpack::math::LinearSolver solver1(*prefy11ybus);
//solver1.configure(cursor);
int t_solve = timer->createCategory("Dynamic Simulation: Solve Linear Equation");
timer->start(t_solve);
gridpack::math::LinearMatrixSolver solver1(*prefy11ybus);
boost::shared_ptr<gridpack::math::Matrix> prefy11X(solver1.solve(*Y_cDense));
timer->stop(t_solve);
///p_branchIO.header("\n=== prefy11X: ============\n");
///prefy11X->print();
//-----------------------------------------------------------------------
// Compute prefy11
//-----------------------------------------------------------------------
// Form reduced admittance matrix prefy11: prefy11 = Y_b * X
timer->start(t_matmul);
boost::shared_ptr<gridpack::math::Matrix> prefy11(multiply(*Y_b, *prefy11X));
timer->stop(t_matmul);
// Update prefy11: prefy11 = Y_a + prefy11
prefy11->add(*Y_a);
///p_branchIO.header("\n=== Reduced Ybus: prefy11: ============\n");
///prefy11->print();
//-----------------------------------------------------------------------
// Compute fy11
// Update ybus values at fault stage
//-----------------------------------------------------------------------
// Read the switch info from faults Event from input.xml
int sw2_2 = fault.from_idx - 1;
int sw3_2 = fault.to_idx - 1;
boost::shared_ptr<gridpack::math::Matrix> fy11ybus(prefy11ybus->clone());
///p_branchIO.header("\n=== fy11ybus(original): ============\n");
///fy11ybus->print();
gridpack::ComplexType x(0.0, -1e7);
#if 0
fy11ybus->setElement(sw2_2, sw2_2, -x);
fy11ybus->ready();
#else
timer->start(t_matset);
p_factory->setEvent(fault);
p_factory->setMode(onFY);
ybusMap.overwriteMatrix(fy11ybus);
timer->stop(t_matset);
#endif
///p_branchIO.header("\n=== fy11ybus: ============\n");
///fy11ybus->print();
// Solve linear equations of fy11ybus * X = Y_c
timer->start(t_solve);
gridpack::math::LinearMatrixSolver solver2(*fy11ybus);
boost::shared_ptr<gridpack::math::Matrix> fy11X(solver2.solve(*Y_cDense));
timer->stop(t_solve);
///p_branchIO.header("\n=== fy11X: ============\n");
///fy11X->print();
// Form reduced admittance matrix fy11: fy11 = Y_b * X
timer->start(t_matmul);
boost::shared_ptr<gridpack::math::Matrix> fy11(multiply(*Y_b, *fy11X));
timer->stop(t_matmul);
// Update fy11: fy11 = Y_a + fy11
fy11->add(*Y_a);
///p_branchIO.header("\n=== Reduced Ybus: fy11: ============\n");
///fy11->print();
//-----------------------------------------------------------------------
// Compute posfy11
// Update ybus values at clear fault stage
//-----------------------------------------------------------------------
// Get the updating factor for posfy11 stage ybus
#if 0
gridpack::ComplexType myValue = p_factory->setFactor(sw2_2, sw3_2);
#endif
timer->start(t_matset);
boost::shared_ptr<gridpack::math::Matrix> posfy11ybus(prefy11ybus->clone());
timer->stop(t_matset);
///p_branchIO.header("\n=== posfy11ybus (original): ============\n");
///posfy11ybus->print();
#if 0
gridpack::ComplexType big(0.0, 1e7);
gridpack::ComplexType x11 = big - myValue;
posfy11ybus->addElement(sw2_2, sw2_2, x+x11);
gridpack::ComplexType x12 = myValue;
posfy11ybus->addElement(sw2_2, sw3_2, x12);
gridpack::ComplexType x21 = myValue;
posfy11ybus->addElement(sw3_2, sw2_2, x21);
gridpack::ComplexType x22 = -myValue;
posfy11ybus->addElement(sw3_2, sw3_2, x22);
posfy11ybus->ready();
#else
timer->start(t_matset);
p_factory->setMode(posFY);
ybusMap.incrementMatrix(posfy11ybus);
timer->stop(t_matset);
#endif
///p_branchIO.header("\n=== posfy11ybus: ============\n");
///posfy11ybus->print();
// Solve linear equations of posfy11ybus * X = Y_c
timer->start(t_solve);
gridpack::math::LinearMatrixSolver solver3(*posfy11ybus);
boost::shared_ptr<gridpack::math::Matrix> posfy11X(solver3.solve(*Y_cDense));
timer->stop(t_solve);
///p_branchIO.header("\n=== posfy11X: ============\n");
///posfy11X->print();
// Form reduced admittance matrix posfy11: posfy11 = Y_b * X
timer->start(t_matmul);
boost::shared_ptr<gridpack::math::Matrix> posfy11(multiply(*Y_b, *posfy11X));
timer->stop(t_matmul);
// Update posfy11: posfy11 = Y_a + posfy11
posfy11->add(*Y_a);
///p_branchIO.header("\n=== Reduced Ybus: posfy11: ============\n");
///posfy11->print();
//-----------------------------------------------------------------------
// Integration implementation (Modified Euler Method)
//-----------------------------------------------------------------------
// Map to create vector pelect
int t_vecset = timer->createCategory("Dynamic Simulation: Setup Vector");
timer->start(t_vecset);
p_factory->setMode(init_pelect);
gridpack::mapper::BusVectorMap<DSNetwork> XMap1(p_network);
boost::shared_ptr<gridpack::math::Vector> pelect = XMap1.mapToVector();
///p_busIO->header("\n=== pelect: ===\n");
///pelect->print();
// Map to create vector eprime_s0
p_factory->setMode(init_eprime);
gridpack::mapper::BusVectorMap<DSNetwork> XMap2(p_network);
boost::shared_ptr<gridpack::math::Vector> eprime_s0 = XMap2.mapToVector();
///p_busIO->header("\n=== eprime: ===\n");
///eprime_s0->print();
// Map to create vector mac_ang_s0
p_factory->setMode(init_mac_ang);
gridpack::mapper::BusVectorMap<DSNetwork> XMap3(p_network);
boost::shared_ptr<gridpack::math::Vector> mac_ang_s0 = XMap3.mapToVector();
///p_busIO->header("\n=== mac_ang_s0: ===\n");
///mac_ang_s0->print();
// Map to create vector mac_spd_s0
p_factory->setMode(init_mac_spd);
gridpack::mapper::BusVectorMap<DSNetwork> XMap4(p_network);
boost::shared_ptr<gridpack::math::Vector> mac_spd_s0 = XMap4.mapToVector();
///p_busIO->header("\n=== mac_spd_s0: ===\n");
///mac_spd_s0->print();
// Map to create vector eqprime
p_factory->setMode(init_eqprime);
gridpack::mapper::BusVectorMap<DSNetwork> XMap5(p_network);
boost::shared_ptr<gridpack::math::Vector> eqprime = XMap5.mapToVector();
///p_busIO->header("\n=== eqprime: ===\n");
///eqprime->print();
// Map to create vector pmech
p_factory->setMode(init_pmech);
gridpack::mapper::BusVectorMap<DSNetwork> XMap6(p_network);
boost::shared_ptr<gridpack::math::Vector> pmech = XMap6.mapToVector();
///p_busIO->header("\n=== pmech: ===\n");
///pmech->print();
// Map to create vector mva
p_factory->setMode(init_mva);
gridpack::mapper::BusVectorMap<DSNetwork> XMap7(p_network);
boost::shared_ptr<gridpack::math::Vector> mva = XMap7.mapToVector();
///p_busIO->header("\n=== mva: ===\n");
///mva->print();
// Map to create vector d0
p_factory->setMode(init_d0);
gridpack::mapper::BusVectorMap<DSNetwork> XMap8(p_network);
boost::shared_ptr<gridpack::math::Vector> d0 = XMap8.mapToVector();
///p_busIO->header("\n=== d0: ===\n");
///d0->print();
// Map to create vector h
p_factory->setMode(init_h);
gridpack::mapper::BusVectorMap<DSNetwork> XMap9(p_network);
boost::shared_ptr<gridpack::math::Vector> h = XMap9.mapToVector();
///p_busIO->header("\n=== h: ===\n");
///h->print();
///p_busIO->header("\n============Start of Simulation:=====================\n");
// Declare vector mac_ang_s1, mac_spd_s1
boost::shared_ptr<gridpack::math::Vector> mac_ang_s1(mac_ang_s0->clone());
boost::shared_ptr<gridpack::math::Vector> mac_spd_s1(mac_spd_s0->clone());
// Declare vector eprime_s1
boost::shared_ptr<gridpack::math::Vector> eprime_s1(mac_ang_s0->clone());
// Declare vector dmac_ang_s0, dmac_spd_s0, dmac_ang_s1, dmac_spd_s1
boost::shared_ptr<gridpack::math::Vector> dmac_ang_s0(mac_ang_s0->clone());
boost::shared_ptr<gridpack::math::Vector> dmac_ang_s1(mac_ang_s0->clone());
boost::shared_ptr<gridpack::math::Vector> dmac_spd_s0(mac_spd_s0->clone());
boost::shared_ptr<gridpack::math::Vector> dmac_spd_s1(mac_spd_s0->clone());
// Declare vector curr
boost::shared_ptr<gridpack::math::Vector> curr(mac_ang_s0->clone());
timer->stop(t_vecset);
timer->start(t_trans);
boost::shared_ptr<gridpack::math::Matrix> trans_prefy11(transpose(*prefy11));
boost::shared_ptr<gridpack::math::Matrix> trans_fy11(transpose(*fy11));
boost::shared_ptr<gridpack::math::Matrix> trans_posfy11(transpose(*posfy11));
timer->stop(t_trans);
timer->start(t_vecset);
boost::shared_ptr<gridpack::math::Vector> vecTemp(mac_ang_s0->clone());
timer->stop(t_vecset);
// Simulation related variables
int simu_k;
int t_step[20];
double t_width[20];
int flagF;
int S_Steps;
int last_S_Steps;
int steps3, steps2, steps1;
double h_sol1, h_sol2;
int flagF1, flagF2;
int I_Steps;
const double sysFreq = 60.0;
double pi = 4.0*atan(1.0);
const double basrad = 2.0 * pi * sysFreq;
gridpack::ComplexType jay(0.0, 1.0);
// switch info is set up here
int nswtch = 4;
static double sw1[4];
static double sw7[4];
sw1[0] = 0.0;
sw1[1] = fault.start;
sw1[2] = fault.end;
sw1[3] = p_sim_time;
sw7[0] = p_time_step;
sw7[1] = fault.step;
sw7[2] = p_time_step;
sw7[3] = p_time_step;
simu_k = 0;
for (int i = 0; i < nswtch-1; i++) {
t_step[i] = (int) ((sw1[i+1] -sw1[i]) / sw7[i]);
t_width[i] = (sw1[i+1] - sw1[i]) / t_step[i];
simu_k += t_step[i];
}
simu_k++;
steps3 = t_step[0] + t_step[1] + t_step[2] - 1;
steps2 = t_step[0] + t_step[1] - 1;
steps1 = t_step[0] - 1;
h_sol1 = t_width[0];
h_sol2 = h_sol1;
flagF1 = 0;
flagF2 = 0;
p_S_Steps = 1;
last_S_Steps = -1;
if (p_generatorWatch) {
p_generatorIO->header("t");
p_generatorIO->write("watch_header");
p_generatorIO->header("\n");
}
for (I_Steps = 0; I_Steps < simu_k+1; I_Steps++) {
if (I_Steps < steps1) {
p_S_Steps = I_Steps;
flagF1 = 0;
flagF2 = 0;
} else if (I_Steps == steps1) {
p_S_Steps = I_Steps;
flagF1 = 0;
flagF2 = 1;
} else if (I_Steps == steps1+1) {
p_S_Steps = I_Steps;
flagF1 = 1;
flagF2 = 1;
} else if ((I_Steps>steps1+1) && (I_Steps<steps2+1)) {
p_S_Steps = I_Steps - 1;
flagF1 = 1;
flagF2 = 1;
} else if (I_Steps==steps2+1) {
p_S_Steps = I_Steps - 1;
flagF1 = 1;
flagF2 = 2;
} else if (I_Steps==steps2+2) {
p_S_Steps = I_Steps - 1;
flagF1 = 2;
flagF2 = 2;
} else if (I_Steps>steps2+2) {
p_S_Steps = I_Steps - 2;
flagF1 = 2;
flagF2 = 2;
}
if (I_Steps !=0 && last_S_Steps != p_S_Steps) {
mac_ang_s0->equate(*mac_ang_s1);
mac_spd_s0->equate(*mac_spd_s1);
eprime_s0->equate(*eprime_s1);
}
vecTemp->equate(*mac_ang_s0);
vecTemp->scale(jay);
vecTemp->exp();
vecTemp->elementMultiply(*eqprime);
eprime_s0->equate(*vecTemp);
// ---------- CALL i_simu_innerloop(k,p_S_Steps,flagF1): ----------
int t_trnsmul = timer->createCategory("Dynamic Simulation: Transpose Multiply");
timer->start(t_trnsmul);
if (flagF1 == 0) {
curr.reset(multiply(*trans_prefy11, *eprime_s0)); //MatMultTranspose(prefy11, eprime_s0, curr);
//transposeMultiply(*prefy11,*eprime_s0,*curr);
} else if (flagF1 == 1) {
curr.reset(multiply(*trans_fy11, *eprime_s0)); //MatMultTranspose(fy11, eprime_s0, curr);
//transposeMultiply(*fy11,*eprime_s0,*curr);
} else if (flagF1 == 2) {
curr.reset(multiply(*trans_posfy11, *eprime_s0)); //MatMultTranspose(posfy11, eprime_s0, curr);
//transposeMultiply(*posfy11,*eprime_s0,*curr);
}
timer->stop(t_trnsmul);
// ---------- CALL mac_em2(k,p_S_Steps): ----------
// ---------- pelect: ----------
curr->conjugate();
vecTemp->equate(*eprime_s0);
vecTemp->elementMultiply(*curr);
pelect->equate(*vecTemp);
pelect->real(); //Get the real part of pelect
// ---------- dmac_ang: ----------
vecTemp->equate(*mac_spd_s0);
vecTemp->add(-1.0);
vecTemp->scale(basrad);
dmac_ang_s0->equate(*vecTemp);
// ---------- dmac_spd: ----------
vecTemp->equate(*pelect);
vecTemp->elementMultiply(*mva);
dmac_spd_s0->equate(*pmech);
dmac_spd_s0->add(*vecTemp, -1.0);
vecTemp->equate(*mac_spd_s0);
vecTemp->add(-1.0);
vecTemp->elementMultiply(*d0);
dmac_spd_s0->add(*vecTemp, -1.0);
vecTemp->equate(*h);
vecTemp->scale(2.0);
dmac_spd_s0->elementDivide(*vecTemp);
mac_ang_s1->equate(*mac_ang_s0);
vecTemp->equate(*dmac_ang_s0);
mac_ang_s1->add(*dmac_ang_s0, h_sol1);
mac_spd_s1->equate(*mac_spd_s0);
vecTemp->equate(*dmac_spd_s0);
mac_spd_s1->add(*vecTemp, h_sol1);
vecTemp->equate(*mac_ang_s1);
vecTemp->scale(jay);
vecTemp->exp();
vecTemp->elementMultiply(*eqprime);
eprime_s1->equate(*vecTemp);
// ---------- CALL i_simu_innerloop2(k,p_S_Steps+1,flagF2): ----------
timer->start(t_trnsmul);
if (flagF2 == 0) {
curr.reset(multiply(*trans_prefy11, *eprime_s1)); //MatMultTranspose(prefy11, eprime_s1, curr);
//transposeMultiply(*prefy11,*eprime_s1,*curr);
} else if (flagF2 == 1) {
curr.reset(multiply(*trans_fy11, *eprime_s1)); //MatMultTranspose(fy11, eprime_s1, curr);
//transposeMultiply(*fy11,*eprime_s1,*curr);
} else if (flagF2 == 2) {
curr.reset(multiply(*trans_posfy11, *eprime_s1)); //MatMultTranspose(posfy11, eprime_s1, curr);
//transposeMultiply(*posfy11,*eprime_s1,*curr);
}
timer->stop(t_trnsmul);
// ---------- CALL mac_em2(k,p_S_Steps+1): ----------
// ---------- pelect: ----------
curr->conjugate();
vecTemp->equate(*eprime_s1);
vecTemp->elementMultiply(*curr);
pelect->equate(*vecTemp);
pelect->real(); //Get the real part of pelect
// ---------- dmac_ang: ----------
vecTemp->equate(*mac_spd_s1);
vecTemp->add(-1.0);
vecTemp->scale(basrad);
dmac_ang_s1->equate(*vecTemp);
// ---------- dmac_spd: ----------
vecTemp->equate(*pelect);
vecTemp->elementMultiply(*mva);
dmac_spd_s1->equate(*pmech);
dmac_spd_s1->add(*vecTemp, -1.0);
vecTemp->equate(*mac_spd_s1);
vecTemp->add(-1.0);
vecTemp->elementMultiply(*d0);
dmac_spd_s1->add(*vecTemp, -1.0);
vecTemp->equate(*h);
vecTemp->scale(2.0);
dmac_spd_s1->elementDivide(*vecTemp);
vecTemp->equate(*dmac_ang_s0);
vecTemp->add(*dmac_ang_s1);
vecTemp->scale(0.5);
mac_ang_s1->equate(*mac_ang_s0);
mac_ang_s1->add(*vecTemp, h_sol2);
vecTemp->equate(*dmac_spd_s0);
vecTemp->add(*dmac_spd_s1);
vecTemp->scale(0.5);
mac_spd_s1->equate(*mac_spd_s0);
mac_spd_s1->add(*vecTemp, h_sol2);
if (p_generatorWatch && I_Steps%p_watchFrequency == 0) {
p_factory->setMode(init_mac_ang);
XMap3.mapToBus(mac_ang_s1);
p_factory->setMode(init_mac_spd);
XMap3.mapToBus(mac_spd_s1);
char tbuf[32];
sprintf(tbuf,"%8.4f",static_cast<double>(I_Steps)*p_time_step);
p_generatorIO->header(tbuf);
p_generatorIO->write("watch");
p_generatorIO->header("\n");
}
// Print to screen
if (last_S_Steps != p_S_Steps) {
//sprintf(ioBuf, "\n========================S_Steps = %d=========================\n", p_S_Steps);
//p_busIO->header(ioBuf);
//mac_ang_s0->print();
//mac_spd_s0->print();
//pmech->print();
//pelect->print();
//sprintf(ioBuf, "========================End of S_Steps = %d=========================\n\n", p_S_Steps);
//p_busIO->header(ioBuf);
}
if (I_Steps == simu_k) {
p_factory->setMode(init_mac_ang);
XMap3.mapToBus(mac_ang_s1);
p_factory->setMode(init_mac_spd);
XMap3.mapToBus(mac_spd_s1);
p_factory->setMode(init_pmech);
XMap6.mapToBus(pmech);
p_factory->setMode(init_pelect);
XMap1.mapToBus(pelect);
//mac_ang_s1->print();
//mac_spd_s1->print();
//pmech->print();
//pelect->print();
} // End of Print to screen
last_S_Steps = p_S_Steps;
}
closeGeneratorWatchFile();
timer->stop(t_total);
#else
timer->start(t_total);
int t_matset = timer->createCategory("Matrix Setup");
timer->start(t_matset);
p_factory->setMode(YBUS);
gridpack::mapper::FullMatrixMap<DSNetwork> ybusMap(p_network);
timer->stop(t_matset);
int t_trans = timer->createCategory("Matrix Transpose");
// Construct matrix diagY_a using xd and ra extracted from gen data,
timer->start(t_matset);
p_factory->setMode(YA);
gridpack::mapper::FullMatrixMap<DSNetwork> yaMap(p_network);
boost::shared_ptr<gridpack::math::Matrix> diagY_a = yaMap.mapToMatrix();
// Convert diagY_a from sparse matrix to dense matrix Y_a so that SuperLU_DIST can solve
gridpack::math::MatrixStorageType denseType = gridpack::math::Dense;
boost::shared_ptr<gridpack::math::Matrix> Y_a(gridpack::math::storageType(*diagY_a, denseType));
timer->stop(t_matset);
int t_matmul = timer->createCategory("Matrix Multiply");
// Construct Y_c as a dense matrix
timer->start(t_matset);
p_factory->setMode(YC);
gridpack::mapper::FullMatrixMap<DSNetwork> cMap(p_network);
boost::shared_ptr<gridpack::math::Matrix> Y_cDense = cMap.mapToMatrix(true);
// Construct Y_b
p_factory->setMode(YB);
gridpack::mapper::FullMatrixMap<DSNetwork> bMap(p_network);
boost::shared_ptr<gridpack::math::Matrix> Y_b = bMap.mapToMatrix();
timer->stop(t_matset);
timer->start(t_matset);
p_factory->setMode(updateYbus);
boost::shared_ptr<gridpack::math::Matrix> prefy11ybus = ybusMap.mapToMatrix();
timer->stop(t_matset);
// Solve linear equations ybus * X = Y_c
int t_solve = timer->createCategory("Solve Linear Equation");
timer->start(t_solve);
gridpack::math::LinearMatrixSolver solver1(*prefy11ybus);
boost::shared_ptr<gridpack::math::Matrix> prefy11X(solver1.solve(*Y_cDense));
timer->stop(t_solve);
//-----------------------------------------------------------------------
// Compute prefy11
//-----------------------------------------------------------------------
// Form reduced admittance matrix prefy11: prefy11 = Y_b * X
timer->start(t_matmul);
boost::shared_ptr<gridpack::math::Matrix> prefy11(multiply(*Y_b, *prefy11X));
timer->stop(t_matmul);
// Update prefy11: prefy11 = Y_a + prefy11
prefy11->add(*Y_a);
//-----------------------------------------------------------------------
// Compute fy11
// Update ybus values at beginning of fault
//-----------------------------------------------------------------------
// Read the switch info from fault. Event from input.xml
int sw2_2 = fault.from_idx - 1;
int sw3_2 = fault.to_idx - 1;
boost::shared_ptr<gridpack::math::Matrix> fy11ybus(prefy11ybus->clone());
gridpack::ComplexType x(0.0, -1e7);
timer->start(t_matset);
p_factory->setEvent(fault);
p_factory->setMode(onFY);
ybusMap.overwriteMatrix(fy11ybus);
timer->stop(t_matset);
// Solve linear equations of fy11ybus * X = Y_c
timer->start(t_solve);
gridpack::math::LinearMatrixSolver solver2(*fy11ybus);
boost::shared_ptr<gridpack::math::Matrix> fy11X(solver2.solve(*Y_cDense));
timer->stop(t_solve);
// Form reduced admittance matrix fy11: fy11 = Y_b * X
timer->start(t_matmul);
boost::shared_ptr<gridpack::math::Matrix> fy11(multiply(*Y_b, *fy11X));
timer->stop(t_matmul);
// Update fy11: fy11 = Y_a + fy11
fy11->add(*Y_a);
//-----------------------------------------------------------------------
// Compute posfy11
// Update ybus values at clear fault stage
//-----------------------------------------------------------------------
// Get the updating factor for posfy11 stage ybus
timer->start(t_matset);
boost::shared_ptr<gridpack::math::Matrix> posfy11ybus(prefy11ybus->clone());
timer->stop(t_matset);
timer->start(t_matset);
p_factory->setMode(posFY);
ybusMap.incrementMatrix(posfy11ybus);
timer->stop(t_matset);
// Solve linear equations of posfy11ybus * X = Y_c
timer->start(t_solve);
gridpack::math::LinearMatrixSolver solver3(*posfy11ybus);
boost::shared_ptr<gridpack::math::Matrix> posfy11X(solver3.solve(*Y_cDense));
timer->stop(t_solve);
// Form reduced admittance matrix posfy11: posfy11 = Y_b * X
timer->start(t_matmul);
boost::shared_ptr<gridpack::math::Matrix> posfy11(multiply(*Y_b, *posfy11X));
timer->stop(t_matmul);
// Update posfy11: posfy11 = Y_a + posfy11
posfy11->add(*Y_a);
//-----------------------------------------------------------------------
// Integration implementation (Modified Euler Method)
//-----------------------------------------------------------------------
p_factory->setDSParams();
p_factory->setMode(Eprime0);
// create vectors used in solution method
gridpack::mapper::BusVectorMap<DSNetwork> Emap(p_network);
boost::shared_ptr<gridpack::math::Vector> eprime_s0 = Emap.mapToVector();
boost::shared_ptr<gridpack::math::Vector> eprime_s1(eprime_s0->clone());
boost::shared_ptr<gridpack::math::Vector> curr(eprime_s0->clone());
timer->start(t_trans);
boost::shared_ptr<gridpack::math::Matrix> trans_prefy11(transpose(*prefy11));
boost::shared_ptr<gridpack::math::Matrix> trans_fy11(transpose(*fy11));
boost::shared_ptr<gridpack::math::Matrix> trans_posfy11(transpose(*posfy11));
timer->stop(t_trans);
// Simulation related variables
int simu_k;
int t_step[20];
double t_width[20];
int flagF;
int S_Steps;
int last_S_Steps;
int steps3, steps2, steps1;
double h_sol1, h_sol2;
int flagF1, flagF2;
int I_Steps;
const double sysFreq = 60.0;
double pi = 4.0*atan(1.0);
const double basrad = 2.0 * pi * sysFreq;
gridpack::ComplexType jay(0.0, 1.0);
// switch info is set up here
int nswtch = 4;
static double sw1[4];
static double sw7[4];
sw1[0] = 0.0;
sw1[1] = fault.start;
sw1[2] = fault.end;
sw1[3] = p_sim_time;
sw7[0] = p_time_step;
sw7[1] = fault.step;
sw7[2] = p_time_step;
sw7[3] = p_time_step;
simu_k = 0;
for (int i = 0; i < nswtch-1; i++) {
t_step[i] = (int) ((sw1[i+1] -sw1[i]) / sw7[i]);
t_width[i] = (sw1[i+1] - sw1[i]) / t_step[i];
simu_k += t_step[i];
}
simu_k++;
steps3 = t_step[0] + t_step[1] + t_step[2] - 1;
steps2 = t_step[0] + t_step[1] - 1;
steps1 = t_step[0] - 1;
h_sol1 = t_width[0];
h_sol2 = h_sol1;
flagF1 = 0;
flagF2 = 0;
S_Steps = 1;
last_S_Steps = -1;
if (p_generatorWatch) {
p_generatorIO->header("t");
if (p_generatorWatch) p_generatorIO->write("watch_header");
p_generatorIO->header("\n");
}
for (I_Steps = 0; I_Steps < simu_k+1; I_Steps++) {
if (I_Steps < steps1) {
S_Steps = I_Steps;
flagF1 = 0;
flagF2 = 0;
} else if (I_Steps == steps1) {
S_Steps = I_Steps;
flagF1 = 0;
flagF2 = 1;
} else if (I_Steps == steps1+1) {
S_Steps = I_Steps;
flagF1 = 1;
flagF2 = 1;
} else if ((I_Steps>steps1+1) && (I_Steps<steps2+1)) {
S_Steps = I_Steps - 1;
flagF1 = 1;
flagF2 = 1;
} else if (I_Steps==steps2+1) {
S_Steps = I_Steps - 1;
flagF1 = 1;
flagF2 = 2;
} else if (I_Steps==steps2+2) {
S_Steps = I_Steps - 1;
flagF1 = 2;
flagF2 = 2;
} else if (I_Steps>steps2+2) {
S_Steps = I_Steps - 2;
flagF1 = 2;
flagF2 = 2;
}
if (I_Steps !=0 && last_S_Steps != S_Steps) {
p_factory->initDSStep(false);
} else {
p_factory->initDSStep(true);
}
p_factory->setMode(Eprime0);
Emap.mapToVector(eprime_s0);
// ---------- CALL i_simu_innerloop(k,S_Steps,flagF1): ----------
int t_trnsmul = timer->createCategory("Transpose Multiply");
timer->start(t_trnsmul);
if (flagF1 == 0) {
curr.reset(multiply(*trans_prefy11, *eprime_s0)); //MatMultTranspose(prefy11, eprime_s0, curr);
//transposeMultiply(*prefy11,*eprime_s0,*curr);
} else if (flagF1 == 1) {
curr.reset(multiply(*trans_fy11, *eprime_s0)); //MatMultTranspose(fy11, eprime_s0, curr);
//transposeMultiply(*fy11,*eprime_s0,*curr);
} else if (flagF1 == 2) {
curr.reset(multiply(*trans_posfy11, *eprime_s0)); //MatMultTranspose(posfy11, eprime_s0, curr);
//transposeMultiply(*posfy11,*eprime_s0,*curr);
}
timer->stop(t_trnsmul);
p_factory->setMode(Current);
Emap.mapToBus(curr);
p_factory->predDSStep(h_sol1);
p_factory->setMode(Eprime1);
Emap.mapToVector(eprime_s1);
// ---------- CALL i_simu_innerloop2(k,S_Steps+1,flagF2): ----------
timer->start(t_trnsmul);
if (flagF2 == 0) {
curr.reset(multiply(*trans_prefy11, *eprime_s1)); //MatMultTranspose(prefy11, eprime_s1, curr);
//transposeMultiply(*prefy11,*eprime_s1,*curr);
} else if (flagF2 == 1) {
curr.reset(multiply(*trans_fy11, *eprime_s1)); //MatMultTranspose(fy11, eprime_s1, curr);
//transposeMultiply(*fy11,*eprime_s1,*curr);
} else if (flagF2 == 2) {
curr.reset(multiply(*trans_posfy11, *eprime_s1)); //MatMultTranspose(posfy11, eprime_s1, curr);
//transposeMultiply(*posfy11,*eprime_s1,*curr);
}
timer->stop(t_trnsmul);
p_factory->setMode(Current);
Emap.mapToBus(curr);
p_factory->corrDSStep(h_sol2);
if (p_generatorWatch && I_Steps%p_watchFrequency == 0) {
char tbuf[32];
sprintf(tbuf,"%8.4f",static_cast<double>(I_Steps)*p_time_step);
p_generatorIO->header(tbuf);
p_generatorIO->write("watch");
p_generatorIO->header("\n");
}
// Print to screen
if (I_Steps == simu_k) {
char ioBuf[128];
sprintf(ioBuf, "\n========================S_Steps = %d=========================\n",
S_Steps+1);
p_busIO->header(ioBuf);
sprintf(ioBuf, "\n Bus ID Generator ID"
" mac_ang mac_spd mech elect\n\n");
p_busIO->header(ioBuf);
p_busIO->write();
sprintf(ioBuf, "\n========================End of S_Steps = %d=========================\n\n",
S_Steps+1);
p_busIO->header(ioBuf);
} // End of Print to screen
last_S_Steps = S_Steps;
}
closeGeneratorWatchFile();
timer->stop(t_total);
#endif
}
void TreeFiller(string inFiles, string outFile, string histName) {
TChain *origFiles = new TChain("treeVars", "treeVars");
origFiles->Add(inFiles.c_str());
int nEntries = origFiles->GetEntries();
cout << "The old chain contains " << nEntries << " entries." << endl;
float puWeight, jet1Eta, jet2Eta, deltaY, genTopPt1, genTopPt2, jet1Mass, jet2Mass, jet1MinMass, jet2MinMass, jet1BDisc, jet2BDisc, jet1SubjetMaxBDisc, jet2SubjetMaxBDisc,
jet1tau32, jet2tau32, jet1Pt, jet2Pt, jet1bSF, jet2bSF, jet1bSFErrUp, jet2bSFErrUp, jet1bSFErrDn, jet2bSFErrDn, jetPtForMistag, mttMass, mttMassPred, mistagWt, mistagWtErr, mistagWtAll, mistagWtNsubAll, mistagWtNsub, NNoutput, ptReweight, cutflow, index, trigWt;
int jet1NSubjets, jet2NSubjets, jet1Parton, jet2Parton, npv;
origFiles->SetBranchAddress("npv", &npv);
origFiles->SetBranchAddress("jet1Eta", &jet1Eta);
origFiles->SetBranchAddress("jet2Eta", &jet2Eta);
origFiles->SetBranchAddress("deltaY", &deltaY);
origFiles->SetBranchAddress("jet1Mass", &jet1Mass);
origFiles->SetBranchAddress("jet2Mass", &jet2Mass);
origFiles->SetBranchAddress("jet1minMass", &jet1MinMass);
origFiles->SetBranchAddress("jet2minMass", &jet2MinMass);
origFiles->SetBranchAddress("jet1Nsubj", &jet1NSubjets);
origFiles->SetBranchAddress("jet2Nsubj", &jet2NSubjets);
origFiles->SetBranchAddress("jet1BDisc", &jet1BDisc);
origFiles->SetBranchAddress("jet2BDisc", &jet2BDisc);
origFiles->SetBranchAddress("jet1SubjetMaxBDisc", &jet1SubjetMaxBDisc);
origFiles->SetBranchAddress("jet2SubjetMaxBDisc", &jet2SubjetMaxBDisc);
origFiles->SetBranchAddress("jet1tau32", &jet1tau32);
origFiles->SetBranchAddress("jet2tau32", &jet2tau32);
origFiles->SetBranchAddress("jet1Pt", &jet1Pt);
origFiles->SetBranchAddress("jet2Pt", &jet2Pt);
origFiles->SetBranchAddress("jetPtForMistag", &jetPtForMistag);
origFiles->SetBranchAddress("mttMass", &mttMass);
origFiles->SetBranchAddress("mttMassPred", &mttMassPred);
origFiles->SetBranchAddress("index", &index);
origFiles->SetBranchAddress("cutflow", &cutflow);
origFiles->SetBranchAddress("NNoutput", &NNoutput);
origFiles->SetBranchAddress("mistagWt", &mistagWt);
origFiles->SetBranchAddress("genTopPt1", &genTopPt1);
origFiles->SetBranchAddress("genTopPt2", &genTopPt2);
origFiles->SetBranchAddress("jet1Parton", &jet1Parton);
origFiles->SetBranchAddress("jet2Parton", &jet2Parton);
origFiles->SetBranchAddress("trigWt", &trigWt);
TFile *newFile = new TFile(outFile.c_str(), "RECREATE");
TTree *newTree = origFiles->CloneTree(0);
newTree->Branch("mistagWtNsub", &mistagWtNsub, "mistagWtNsub/F");
newTree->Branch("mistagWtNsubAll", &mistagWtNsubAll, "mistagWtNsubAll/F");
newTree->Branch("mistagWtAll", &mistagWtAll, "mistagWtAll/F");
newTree->Branch("ptReweight", &ptReweight, "ptReweight/F");
newTree->Branch("puWeight", &puWeight, "puWeight/F");
newTree->Branch("jet1bSF", &jet1bSF, "jet1bSF/F");
newTree->Branch("jet2bSF", &jet2bSF, "jet2bSF/F");
newTree->Branch("jet1bSFErrUp", &jet1bSFErrUp, "jet1bSFErrUp/F");
newTree->Branch("jet2bSFErrUp", &jet2bSFErrUp, "jet2bSFErrUp/F");
newTree->Branch("jet1bSFErrDn", &jet1bSFErrDn, "jet1bSFErrDn/F");
newTree->Branch("jet2bSFErrDn", &jet2bSFErrDn, "jet2bSFErrDn/F");
newTree->Branch("mistagWtErr", &mistagWtErr, "mistagWtErr/F");
newTree->SetBranchAddress("mistagWtNsub", &mistagWtNsub);
newTree->SetBranchAddress("misagWtNsubAll", &mistagWtNsubAll);
newTree->SetBranchAddress("mistagWtAll", &mistagWtAll);
newTree->SetBranchAddress("ptReweight", &ptReweight);
newTree->SetBranchAddress("puWeight", &puWeight);
newTree->SetBranchAddress("mistagWtErr", &mistagWtErr);
/*
TMVA::Reader* reader = new TMVA::Reader();
reader->AddVariable("jet1Eta", &jet1Eta);
reader->AddVariable("jet2Eta", &jet2Eta);
reader->AddVariable("deltaY", &deltaY);
reader->AddVariable("jet1Mass", &jet1Mass);
reader->AddVariable("jet2Mass", &jet2Mass);
reader->AddVariable("jet1BDisc", &jet1BDisc);
reader->AddVariable("jet2BDisc", &jet2BDisc);
reader->AddVariable("jet1SubjetMaxBDisc", &jet1SubjetMaxBDisc);
reader->AddVariable("jet2SubjetMaxBDisc", &jet2SubjetMaxBDisc);
reader->AddVariable("jet1tau32", &jet1tau32);
reader->AddVariable("jet2tau32", &jet2tau32);
reader->AddVariable("jet1Pt", &jet1Pt);
reader->AddVariable("jet2Pt", &jet2Pt);
reader->AddVariable("mttMass", &mttMass);
reader->BookMVA("MLP", "weights/TMVA_tt_Zp_MLP.weightsZp10_cut4.xml");
*/
//TFile *mistagFileLow = new TFile("notCSVL_notCSVM_mistag.root");
//TFile *mistagFileMed = new TFile("CSVL_notCSVM_mistag.root");
//TFile *mistagFileHi = new TFile("CSVM_mistag.root");
TFile *mistagFile = new TFile("Jul3_mistag.root");//data_AllBscore_mistag_Dec16.root");
histName = "MISTAG_RATE_SUB_TTBAR_Inclusive";
TFile *triggerFile = new TFile("trigger_weights.root");
TH1F *triggerHist = (TH1F *) triggerFile->Get("triggerHist");
TH3F *mistagRateHistAll = (TH3F *) mistagFile->Get( histName.c_str() )->Clone();
cout << histName << endl;
cout << "Entries " << mistagRateHistAll->Integral() << endl;
TFile *puFile = new TFile("puHists.root");
TH1F *puWeightsHist = (TH1F *) puFile->Get("weightsH");
for (int i = 0; i < origFiles->GetEntries(); i++){
origFiles->GetEntry(i);
if (i % 1000000 == 0) cout << 100*(float(i) / float(nEntries)) << " Percent Complete." << endl;
mistagWt = 0.000;
mistagWtNsub = 30.0000;
puWeight = puWeightsHist->GetBinContent(npv);
triggerWt = triggerHist->GetBinContent( triggerHist->FindBin( jet1Pt + jet2Pt ) );
if (cutflow == 4 || index == 1){
if (genTopPt1 > 400) genTopPt1 = 400;
if (genTopPt2 > 400) genTopPt2 = 400;
//NNoutput = reader->EvaluateMVA("MLP");
ptReweight = sqrt( exp(0.156 - 0.00137*genTopPt1)*exp(0.156 - 0.00137*genTopPt2) );
jet1bSF = 1.0;
jet1bSFErrUp = 1.0;
jet1bSFErrDn = 1.0;
jet2bSF = 1.0;
jet2bSFErrUp = 1.0;
jet2bSFErrDn = 1.0;
if (jet1BDisc > 0.679){
jet1bSF = findBSF(jet1Pt, jet1Eta, jet1Parton, 0);
jet1bSFErrUp = findBSF(jet1Pt, jet1Eta, jet1Parton, 1);
jet1bSFErrDn = findBSF(jet1Pt, jet1Eta, jet1Parton, -1);
}
if (jet2BDisc > 0.679){
jet2bSF = findBSF(jet2Pt, jet2Eta, jet2Parton, 0);
jet2bSFErrUp = findBSF(jet2Pt, jet2Eta, jet2Parton, 1);
jet2bSFErrDn = findBSF(jet2Pt, jet2Eta, jet2Parton, -1);
}
if (index == 1) {
float bScore = -9.99;
float tauScore = 9.99;
int probeJet = 0;
if (jet1Pt == jetPtForMistag) {
probeJet = 1;
bScore = jet1SubjetMaxBDisc;
tauScore = jet1tau32;
}
if (jet2Pt == jetPtForMistag) {
bScore = jet2SubjetMaxBDisc;
tauScore = jet2tau32;
probeJet = 2;
}
int bin = mistagRateHistAll->FindBin( ptMap(jetPtForMistag),bMap(bScore),tauMap(tauScore) );
mistagWt = mistagRateHistAll->GetBinContent( bin );
mistagWtErr = mistagRateHistAll->GetBinError( bin );
}
newTree->Fill();
}
}
newFile->cd();
newTree->Write();
newFile->Write();
newFile->Close();
}
