static glbsp_ret_e HandleLevel(void)
{
superblock_t *seg_list;
node_t *root_node;
node_t *root_stale_node;
subsec_t *root_sub;
glbsp_ret_e ret;
if (cur_comms->cancelled)
return GLBSP_E_Cancelled;
DisplaySetBarLimit(1, 1000);
DisplaySetBar(1, 0);
cur_comms->build_pos = 0;
LoadLevel();
InitBlockmap();
// create initial segs
seg_list = CreateSegs();
root_stale_node = (num_stale_nodes == 0) ? NULL :
LookupStaleNode(num_stale_nodes - 1);
// recursively create nodes
ret = BuildNodes(seg_list, &root_node, &root_sub, 0, root_stale_node);
FreeSuper(seg_list);
if (ret == GLBSP_E_OK)
{
ClockwiseBspTree(root_node);
PrintVerbose("Built %d NODES, %d SSECTORS, %d SEGS, %d VERTEXES\n",
num_nodes, num_subsecs, num_segs, num_normal_vert + num_gl_vert);
if (root_node)
PrintVerbose("Heights of left and right subtrees = (%d,%d)\n",
ComputeBspHeight(root_node->r.node),
ComputeBspHeight(root_node->l.node));
SaveLevel(root_node);
}
FreeLevel();
FreeQuickAllocCuts();
FreeQuickAllocSupers();
return ret;
}
void PruneSidedefs(void)
{
int i;
int new_num;
int unused = 0;
DisplayTicker();
// scan all sidedefs
for (i=0, new_num=0; i < num_sidedefs; i++)
{
sidedef_t *S = lev_sidedefs[i];
if (S->ref_count < 0)
InternalError("Sidedef %d ref_count is %d", i, S->ref_count);
if (S->ref_count == 0)
{
if (S->sector)
S->sector->ref_count--;
if (S->equiv == NULL)
unused++;
UtilFree(S);
continue;
}
S->index = new_num;
lev_sidedefs[new_num++] = S;
}
if (new_num < num_sidedefs)
{
int dup_num = num_sidedefs - new_num - unused;
if (unused > 0)
PrintVerbose("Pruned %d unused sidedefs\n", unused);
if (dup_num > 0)
PrintVerbose("Pruned %d duplicate sidedefs\n", dup_num);
num_sidedefs = new_num;
}
if (new_num == 0)
FatalError("Couldn't find any Sidedefs");
}
void PruneVertices(void)
{
int i;
int new_num;
int unused = 0;
DisplayTicker();
// scan all vertices
for (i=0, new_num=0; i < num_vertices; i++)
{
vertex_t *V = lev_vertices[i];
if (V->ref_count < 0)
InternalError("Vertex %d ref_count is %d", i, V->ref_count);
if (V->ref_count == 0)
{
if (V->equiv == NULL)
unused++;
UtilFree(V);
continue;
}
V->index = new_num;
lev_vertices[new_num++] = V;
}
if (new_num < num_vertices)
{
int dup_num = num_vertices - new_num - unused;
if (unused > 0)
PrintVerbose("Pruned %d unused vertices "
"(this is normal if the nodes were built before)\n", unused);
if (dup_num > 0)
PrintVerbose("Pruned %d duplicate vertices\n", dup_num);
num_vertices = new_num;
}
if (new_num == 0)
FatalError("Couldn't find any Vertices");
num_normal_vert = num_vertices;
}
void UAblSetShaderParameterTask::InternalSetShaderValue(UMaterialInstanceDynamic* DynMaterial, UAblSetParameterValue* Value, UAblSetParameterValue* PreviousValue, float BlendAlpha) const
{
check(DynMaterial);
check(Value);
check(PreviousValue);
#if !(UE_BUILD_SHIPPING)
if (IsVerbose())
{
PrintVerbose(FString::Printf(TEXT("Setting material parameter %s on Material %s to %s with a blend of %1.4f."), *m_ParameterName.ToString(), *DynMaterial->GetName(), *Value->ToString(), BlendAlpha));
}
#endif
if (UAblSetScalarParameterValue* ScalarValue = Cast<UAblSetScalarParameterValue>(Value))
{
UAblSetScalarParameterValue* PreviousScalarValue = CastChecked<UAblSetScalarParameterValue>(PreviousValue);
float InterpolatedValue = FMath::Lerp(PreviousScalarValue->GetScalar(), ScalarValue->GetScalar(), BlendAlpha);
DynMaterial->SetScalarParameterValue(m_ParameterName, InterpolatedValue);
}
else if (UAblSetVectorParameterValue* VectorValue = Cast<UAblSetVectorParameterValue>(Value))
{
UAblSetVectorParameterValue* PreviousVectorValue = CastChecked<UAblSetVectorParameterValue>(PreviousValue);
FVector InterpolatedValue = FMath::Lerp(PreviousVectorValue->GetVector(), VectorValue->GetVector(), BlendAlpha);
DynMaterial->SetVectorParameterValue(m_ParameterName, InterpolatedValue);
}
else if (UAblSetTextureParameterValue* TextureValue = Cast<UAblSetTextureParameterValue>(Value))
{
// No Lerping allowed.
DynMaterial->SetTextureParameterValue(m_ParameterName, TextureValue->GetTexture());
}
else
{
checkNoEntry();
}
}
void PruneSectors(void)
{
int i;
int new_num;
DisplayTicker();
// scan all sectors
for (i=0, new_num=0; i < num_sectors; i++)
{
sector_t *S = lev_sectors[i];
if (S->ref_count < 0)
InternalError("Sector %d ref_count is %d", i, S->ref_count);
if (S->ref_count == 0)
{
UtilFree(S);
continue;
}
S->index = new_num;
lev_sectors[new_num++] = S;
}
if (new_num < num_sectors)
{
PrintVerbose("Pruned %d unused sectors\n", num_sectors - new_num);
num_sectors = new_num;
}
if (new_num == 0)
FatalError("Couldn't find any Sectors");
}
//
// ReadWadFile
//
glbsp_ret_e ReadWadFile(const char *filename)
{
int check;
char *read_msg;
// open input wad file & read header
in_file = fopen(filename, "rb");
if (! in_file)
{
if (errno == ENOENT)
SetErrorMsg("Cannot open WAD file: %s", filename);
else
SetErrorMsg("Cannot open WAD file: %s [%s]", filename,
strerror(errno));
return GLBSP_E_ReadError;
}
if (! ReadHeader(filename))
{
fclose(in_file);
return GLBSP_E_ReadError;
}
PrintMsg("Opened %cWAD file : %s\n", (wad.kind == IWAD) ? 'I' : 'P',
filename);
PrintVerbose("Reading %d dir entries at 0x%X\n", wad.num_entries,
wad.dir_start);
// read directory
ReadDirectory();
DisplayOpen(DIS_FILEPROGRESS);
DisplaySetTitle("glBSP Reading Wad");
read_msg = UtilFormat("Reading: %s", filename);
DisplaySetBarText(1, read_msg);
DisplaySetBarLimit(1, CountLumpTypes(LUMP_READ_ME, LUMP_READ_ME));
DisplaySetBar(1, 0);
UtilFree(read_msg);
cur_comms->file_pos = 0;
// now read lumps
check = ReadAllLumps();
if (check != wad.num_entries)
InternalError("Read directory count consistency failure (%d,%d)",
check, wad.num_entries);
wad.current_level = NULL;
DisplayClose();
return GLBSP_E_OK;
}
//
// PutReject
//
// For now we only do very basic reject processing, limited to
// determining all isolated groups of sectors (islands that are
// surrounded by void space).
//
void PutReject(void)
{
CreateLevelLump("REJECT");
// AppendLevelLump(lump, matrix, reject_size);
PrintVerbose("Added empty reject lump\n");
}
int
main(int argc, char **argv)
{
char *programName = argv[0];
if (strrchr(programName, '/'))
programName = strrchr(programName, '/') + 1;
bool showBlocks = false;
bool all = false;
dev_t device = -1;
while (*++argv) {
char *arg = *argv;
if (*arg == '-') {
while (*++arg && isalpha(*arg)) {
switch (arg[0]) {
case 'a':
all = true;
break;
case 'b':
showBlocks = true;
break;
default:
ShowUsage(programName);
}
}
if (arg[0] == '-') {
arg++;
if (!strcmp(arg, "all"))
all = true;
else if (!strcmp(arg, "blocks"))
showBlocks = true;
else
ShowUsage(programName);
}
} else
break;
}
// Do we already have a device? Then let's print out detailed info about that
if (argv[0] != NULL) {
PrintVerbose(dev_for_path(argv[0]));
return 0;
}
// If not, then just iterate over all devices and give a compact summary
printf("Mount Type Total Free Flags Device\n"
"--------------- -------- --------- --------- ------- --------------------------\n");
int32 cookie = 0;
while ((device = next_dev(&cookie)) >= B_OK) {
PrintCompact(device, showBlocks, all);
}
return 0;
}
// The first message of a file transfer is a discovery request byt the client. This function handles such requests.
HRESULT CFileRepServer::SendFileInfo(
__in CRequest* request,
__in_z const LPWSTR fileName,
__in LONGLONG fileLength,
__in DWORD chunkSize)
{
PrintVerbose(L"Entering CFileRepServer::SendFileInfo");
HRESULT hr = S_OK;
WS_ERROR* error = request->GetError();
WS_MESSAGE* replyMessage = request->GetReplyMessage();
WS_MESSAGE* requestMessage = request->GetRequestMessage();
WS_CHANNEL* channel = request->GetChannel();
FileInfo fileInfo;
fileInfo.fileName = fileName;
fileInfo.fileLength = fileLength;
fileInfo.chunkSize = chunkSize;
WS_MESSAGE_DESCRIPTION fileInfoMessageDescription;
fileInfoMessageDescription.action = &fileInfoAction;
fileInfoMessageDescription.bodyElementDescription = &fileInfoElement;
hr = WsSendReplyMessage(
channel,
replyMessage,
&fileInfoMessageDescription,
WS_WRITE_REQUIRED_VALUE,
&fileInfo,
sizeof(fileInfo),
requestMessage,
NULL,
error);
if (FAILED(hr))
{
PrintError(L"CFileRepServer::SendFileInfo", true);
PrintError(hr, error, true);
}
WsResetMessage(replyMessage, NULL);
PrintVerbose(L"Leaving CFileRepServer::SendFileInfo");
return hr;
}
// The server version of ProcessMessage. This is the entry point for the application-specific code.
HRESULT CFileRepServer::ProcessMessage(
__in CRequest* request,
__in const WS_XML_STRING* receivedAction)
{
PrintVerbose(L"Entering CFileRepServer::ProcessMessage");
HRESULT hr = S_OK;
FileRequest* fileRequest = NULL;
WS_MESSAGE* requestMessage = request->GetRequestMessage();
WS_CHANNEL* channel = request->GetChannel();
WS_ERROR* error = request->GetError();
// Make sure action is what we expect
if (WsXmlStringEquals(receivedAction, &fileRequestAction, error) != S_OK)
{
PrintInfo(L"Illegal action");
hr = WS_E_ENDPOINT_ACTION_NOT_SUPPORTED;
}
else
{
// Read file request
WS_HEAP* heap;
IfFailedExit(WsGetMessageProperty(requestMessage, WS_MESSAGE_PROPERTY_HEAP, &heap, sizeof(heap), error));
IfFailedExit(WsReadBody(requestMessage, &fileRequestElement, WS_READ_REQUIRED_POINTER,
heap, &fileRequest, sizeof(fileRequest), error));
IfFailedExit(WsReadMessageEnd(channel, requestMessage, NULL, error));
IfFailedExit(ReadAndSendFile(request, fileRequest->fileName, fileRequest->filePosition, error));
}
EXIT
// We do not print error messages here. That is handled in the caller.
PrintVerbose(L"Leaving CFileRepServer::ProcessMessage");
return hr;
}
void DetectOverlappingLines(void)
{
// Algorithm:
// Sort all lines by left-most vertex.
// Overlapping lines will then be near each other in this set.
// Note: does not detect partially overlapping lines.
int i;
int *array = UtilCalloc(num_linedefs * sizeof(int));
int count = 0;
DisplayTicker();
// sort array of indices
for (i=0; i < num_linedefs; i++)
array[i] = i;
qsort(array, num_linedefs, sizeof(int), LineStartCompare);
for (i=0; i < num_linedefs - 1; i++)
{
int j;
for (j = i+1; j < num_linedefs; j++)
{
if (LineStartCompare(array + i, array + j) != 0)
break;
if (LineEndCompare(array + i, array + j) == 0)
{
linedef_t *A = lev_linedefs[array[i]];
linedef_t *B = lev_linedefs[array[j]];
// found an overlap !
B->overlap = A->overlap ? A->overlap : A;
count++;
}
}
}
if (count > 0)
{
PrintVerbose("Detected %d overlapped linedefs\n", count);
}
UtilFree(array);
}
void UAblSetCollisionChannelResponseTask::OnTaskEnd(const TWeakObjectPtr<const UAblAbilityContext>& Context, const EAblAbilityTaskResult result) const
{
Super::OnTaskEnd(Context, result);
if (m_RestoreOnEnd)
{
UAblSetCollisionChannelResponseTaskScratchPad* ScratchPad = Cast<UAblSetCollisionChannelResponseTaskScratchPad>(Context->GetScratchPadForTask(this));
check(ScratchPad);
for (const FCollisionLayerResponseEntry& Entry : ScratchPad->PreviousCollisionValues)
{
if (Entry.Primitive.IsValid())
{
#if !(UE_BUILD_SHIPPING)
if (IsVerbose())
{
PrintVerbose(FString::Printf(TEXT("Setting Collision Channel %s Response on Actor %s to %s."), *FAbleLogHelper::GetCollisionChannelEnumAsString(Entry.Channel), *Entry.Primitive->GetOwner()->GetName(), *FAbleLogHelper::GetCollisionResponseEnumAsString(Entry.Response)));
}
#endif
Entry.Primitive->SetCollisionResponseToChannel(Entry.Channel, Entry.Response);
}
}
}
}
glbsp_ret_e GlbspBuildNodes(const nodebuildinfo_t *info,
const nodebuildfuncs_t *funcs, volatile nodebuildcomms_t *comms)
{
char *file_msg;
glbsp_ret_e ret = GLBSP_E_OK;
cur_info = info;
cur_funcs = funcs;
cur_comms = comms;
cur_comms->total_big_warn = 0;
cur_comms->total_small_warn = 0;
// clear cancelled flag
comms->cancelled = FALSE;
// sanity check
if (!cur_info->input_file || cur_info->input_file[0] == 0 ||
!cur_info->output_file || cur_info->output_file[0] == 0)
{
SetErrorMsg("INTERNAL ERROR: Missing in/out filename !");
return GLBSP_E_BadArgs;
}
InitDebug();
InitEndian();
if (info->missing_output)
PrintMsg("* No output file specified. Using: %s\n\n", info->output_file);
if (info->same_filenames)
PrintMsg("* Output file is same as input file. Using -loadall\n\n");
// opens and reads directory from the input wad
ret = ReadWadFile(cur_info->input_file);
if (ret != GLBSP_E_OK)
{
TermDebug();
return ret;
}
if (CountLevels() <= 0)
{
CloseWads();
TermDebug();
SetErrorMsg("No levels found in wad !");
return GLBSP_E_Unknown;
}
PrintMsg("\n");
PrintVerbose("Creating nodes using tunable factor of %d\n", info->factor);
DisplayOpen(DIS_BUILDPROGRESS);
DisplaySetTitle("glBSP Build Progress");
file_msg = UtilFormat("File: %s", cur_info->input_file);
DisplaySetBarText(2, file_msg);
DisplaySetBarLimit(2, CountLevels() * 10);
DisplaySetBar(2, 0);
UtilFree(file_msg);
cur_comms->file_pos = 0;
// loop over each level in the wad
while (FindNextLevel())
{
ret = HandleLevel();
if (ret != GLBSP_E_OK)
break;
cur_comms->file_pos += 10;
DisplaySetBar(2, cur_comms->file_pos);
}
DisplayClose();
// writes all the lumps to the output wad
if (ret == GLBSP_E_OK)
{
ret = WriteWadFile(cur_info->output_file);
// when modifying the original wad, any GWA companion must be deleted
if (ret == GLBSP_E_OK && cur_info->same_filenames)
DeleteGwaFile(cur_info->output_file);
PrintMsg("\n");
PrintMsg("Total serious warnings: %d\n", cur_comms->total_big_warn);
PrintMsg("Total minor warnings: %d\n", cur_comms->total_small_warn);
ReportFailedLevels();
}
// close wads and free memory
CloseWads();
TermDebug();
cur_info = NULL;
cur_comms = NULL;
cur_funcs = NULL;
return ret;
}
void UAblRayCastQueryTask::OnTaskStart(const TWeakObjectPtr<const UAblAbilityContext>& Context) const
{
Super::OnTaskStart(Context);
AActor* SourceActor = m_QueryLocation.GetSourceActor(*Context.Get());
check(SourceActor);
UWorld* World = SourceActor->GetWorld();
FTransform QueryTransform;
m_QueryLocation.GetTransform(*Context.Get(), QueryTransform);
const FVector RayStart = QueryTransform.GetLocation();
const FVector RayEnd = RayStart + QueryTransform.GetRotation().GetForwardVector() * m_Length;
if (m_UseAsyncQuery && UAbleSettings::IsAsyncEnabled())
{
UAblRayCastQueryTaskScratchPad* ScratchPad = Cast<UAblRayCastQueryTaskScratchPad>(Context->GetScratchPadForTask(this));
check(ScratchPad);
if (m_OnlyReturnBlockingHit)
{
ScratchPad->AsyncHandle = World->AsyncLineTraceByChannel(EAsyncTraceType::Single, RayStart, RayEnd, m_CollisionChannel);
}
else
{
ScratchPad->AsyncHandle = World->AsyncLineTraceByChannel(EAsyncTraceType::Multi, RayStart, RayEnd, m_CollisionChannel);
}
}
else
{
TArray<FHitResult> HitResults;
FHitResult TraceResult;
if (m_OnlyReturnBlockingHit)
{
if (World->LineTraceSingleByChannel(TraceResult, RayStart, RayEnd, m_CollisionChannel))
{
HitResults.Add(TraceResult);
}
}
else
{
World->LineTraceMultiByChannel(HitResults, RayStart, RayEnd, m_CollisionChannel);
}
#if !(UE_BUILD_SHIPPING)
if (IsVerbose())
{
PrintVerbose(FString::Printf(TEXT("Raycast found %d results."), HitResults.Num()));
}
#endif
if (HitResults.Num())
{
#if !(UE_BUILD_SHIPPING)
if (IsVerbose())
{
// Quick distance print help to see if we hit ourselves.
float DistanceToBlocker = HitResults[HitResults.Num() - 1].Distance;
PrintVerbose(FString::Printf(TEXT("Raycast blocking hit distance: %4.2f."), DistanceToBlocker));
}
#endif
if (m_CopyResultsToContext)
{
#if !(UE_BUILD_SHIPPING)
if (IsVerbose())
{
PrintVerbose(FString::Printf(TEXT("Copying %d results into Context."), HitResults.Num()));
}
#endif
CopyResultsToContext(HitResults, Context);
}
if (m_FireEvent)
{
#if !(UE_BUILD_SHIPPING)
if (IsVerbose())
{
PrintVerbose(FString::Printf(TEXT("Firing Raycast Event %s with %d results."), *m_Name.ToString(), HitResults.Num()));
}
#endif
Context->GetAbility()->OnRaycastEvent(Context.Get(), m_Name, HitResults);
}
}
}
#if !UE_BUILD_SHIPPING
if (FAblAbilityDebug::ShouldDrawQueries())
{
FAblAbilityDebug::DrawRaycastQuery(World, QueryTransform, m_Length);
}
#endif
}
void UAblSetCollisionChannelResponseTask::OnTaskStart(const TWeakObjectPtr<const UAblAbilityContext>& Context) const
{
Super::OnTaskStart(Context);
UAblSetCollisionChannelResponseTaskScratchPad* ScratchPad = nullptr;
if (m_RestoreOnEnd)
{
ScratchPad = Cast<UAblSetCollisionChannelResponseTaskScratchPad>(Context->GetScratchPadForTask(this));
check(ScratchPad);
}
// We need to convert our Actors to primitive components.
TArray<TWeakObjectPtr<AActor>> TargetArray;
GetActorsForTask(Context, TargetArray);
TArray<TWeakObjectPtr<UPrimitiveComponent>> PrimitiveComponents;
for (TWeakObjectPtr<AActor>& Target : TargetArray)
{
if (UPrimitiveComponent* PrimitiveComponent = Cast<UPrimitiveComponent>(Target->GetRootComponent()))
{
PrimitiveComponents.AddUnique(PrimitiveComponent);
}
}
for (TWeakObjectPtr<UPrimitiveComponent>& Component : PrimitiveComponents)
{
if (Component.IsValid())
{
if (m_RestoreOnEnd)
{
if (m_SetAllChannelsToResponse)
{
const FCollisionResponseContainer& Container = Component->GetCollisionResponseToChannels();
for (ECollisionChannel Channel : TEnumRange<ECollisionChannel>())
{
ScratchPad->PreviousCollisionValues.Add(FCollisionLayerResponseEntry(Component.Get(), Channel, Container.GetResponse(Channel)));
}
}
else
{
ScratchPad->PreviousCollisionValues.Add(FCollisionLayerResponseEntry(Component.Get(), m_Channel.GetValue(), Component->GetCollisionResponseToChannel(m_Channel)));
}
}
if (m_SetAllChannelsToResponse)
{
#if !(UE_BUILD_SHIPPING)
if (IsVerbose())
{
PrintVerbose(FString::Printf(TEXT("Setting All Collision Responses on Actor %s to %s."), *Component->GetOwner()->GetName(), *FAbleLogHelper::GetCollisionResponseEnumAsString(m_Response.GetValue())));
}
#endif
Component->SetCollisionResponseToAllChannels(m_Response.GetValue());
}
else
{
#if !(UE_BUILD_SHIPPING)
if (IsVerbose())
{
PrintVerbose(FString::Printf(TEXT("Setting Collision Channel %s Response on Actor %s to %s."), *FAbleLogHelper::GetCollisionChannelEnumAsString(m_Channel.GetValue()), *Component->GetOwner()->GetName(), *FAbleLogHelper::GetCollisionResponseEnumAsString(m_Response.GetValue())));
}
#endif
Component->SetCollisionResponseToChannel(m_Channel.GetValue(), m_Response.GetValue());
}
}
}
}
/* Main Function */
int main(int argc, char *argv[])
{
char *filename = "shalehills"; /* Input file name prefix */
char *StateFile; /* Output file name string */
char *FluxFile;
char *ETISFile;
char *QFile;
Model_Data mData; /* Model Data */
Control_Data cData; /* Solver Control Data */
N_Vector CV_Y; /* State Variables Vector */
M_Env machEnv; /* Machine Environments */
realtype ropt[OPT_SIZE]; /* Optional real type and integer type */
long int iopt[OPT_SIZE]; /* vecter for Message Passing to solver */
void *cvode_mem; /* Model Data Pointer */
int flag; /* flag to test return value */
FILE *res_state_file; /* Output file for States */
FILE *res_flux_file; /* Output file for Flux */
FILE *res_etis_file; /* Output file for ET and IS */
FILE *res_q_file;
int N; /* Problem size */
int i; /* loop index */
realtype t; /* simulation time */
realtype NextPtr, StepSize; /* stress period & step size */
clock_t start, end_r, end_s; /* system clock at points */
realtype cputime_r, cputime_s; /* for duration in realtype */
/* allocate memory for model data structure */
mData = (Model_Data)malloc(sizeof *mData);
start = clock();
/* get user specified file name in command line */
if(argc >= 2)
{
filename = (char *)malloc(strlen(argv[1])*sizeof(char));
strcpy(filename, argv[1]);
}
printf("\nBelt up! PIHM 1.0 is starting ... \n");
/* read in 7 input files with "filename" as prefix */
read_alloc(filename, mData, &cData);
/* problem size */
N = 3*mData->NumEle + mData->NumRiv;
/* initial machine environment variable */
machEnv = M_EnvInit_Serial(N);
/* initial state variable depending on machine*/
CV_Y = N_VNew(N, machEnv);
/* initialize mode data structure */
initialize(filename, mData, &cData, CV_Y);
if(cData.Debug == 1) {PrintModelData(mData);}
end_r = clock();
cputime_r = (end_r - start)/(realtype)CLOCKS_PER_SEC;
printf("\nSolving ODE system ... \n");
/* initial control parameter for CVODE solver. Otherwise the default value by C could cause problems. */
for(i=0; i<OPT_SIZE; i++)
{
ropt[i] = 0.0;
iopt[i] = 0;
}
/* set user specified control parameter */
ropt[H0] = cData.InitStep;
ropt[HMAX] = cData.MaxStep;
/* allocate memory for solver */
cvode_mem = CVodeMalloc(N, f, cData.StartTime, CV_Y, BDF, NEWTON, SS, &cData.reltol,
&cData.abstol, mData, NULL, TRUE, iopt, ropt, machEnv);
if(cvode_mem == NULL) {printf("CVodeMalloc failed. \n"); return(1);}
if(cData.Solver == 1)
{
/* using dense direct solver */
flag = CVDense(cvode_mem, NULL, NULL);
if(flag != SUCCESS) {printf("CVDense failed. \n"); return(1);}
}
else if(cData.Solver == 2)
{
/* using iterative solver */
flag = CVSpgmr(cvode_mem, NONE, cData.GSType, cData.MaxK, cData.delt, NULL, NULL,
mData, NULL, NULL);
if (flag != SUCCESS) {printf("CVSpgmr failed."); return(1);}
}
/*allocate and copy to get output file name */
StateFile = (char *)malloc((strlen(filename)+4)*sizeof(char));
strcpy(StateFile, filename);
FluxFile = (char *)malloc((strlen(filename)+5)*sizeof(char));
strcpy(FluxFile, filename);
ETISFile = (char *)malloc((strlen(filename)+5)*sizeof(char));
strcpy(ETISFile, filename);
QFile = (char *)malloc((strlen(filename)+2)*sizeof(char));
strcpy(QFile, filename);
/* open output file */
if (cData.res_out == 1) {res_state_file = fopen(strcat(StateFile, ".res"), "w");}
if (cData.flux_out == 1) {res_flux_file = fopen(strcat(FluxFile, ".flux"), "w");}
if (cData.etis_out == 1) {res_etis_file = fopen(strcat(ETISFile, ".etis"), "w");}
if (cData.q_out == 1) {res_q_file = fopen(strcat(QFile, ".q"), "w");}
/* print header of output file */
if (cData.res_out == 1) {FPrintYheader(res_state_file, mData);}
if (cData.etis_out == 1) {FPrintETISheader(res_etis_file, mData);}
if (cData.q_out == 1) {FPrintETISheader(res_q_file, mData);}
printf("\n");
/* set start time */
t = cData.StartTime;
/* start solver in loops */
for(i=0; i<cData.NumSteps; i++)
{
/* prompt information in non-verbose mode */
if (cData.Verbose != 1)
{
printf(" Running: %-4.1f%% ... ", (100*(i+1)/((realtype) cData.NumSteps)));
fflush(stdout);
}
/* inner loops to next output points with ET step size control */
while(t < cData.Tout[i+1])
{
if (t + cData.ETStep >= cData.Tout[i+1])
{
NextPtr = cData.Tout[i+1];
}
else
{
NextPtr = t + cData.ETStep;
}
StepSize = NextPtr - t;
/* calculate Interception Storage */
calIS(t, StepSize, mData);
/* solving ODE system */
flag = CVode(cvode_mem, NextPtr, CV_Y, &t, NORMAL);
/* calculate ET and adjust states variables*/
calET(t, StepSize, CV_Y, mData);
}
if(cData.Verbose == 1) {PrintVerbose(i, t, iopt, ropt);}
/* uncomment it if user need it verbose mode */
/* if(cData.Verbose == 1) {PrintY(mData, CV_Y, t);} */
/* print out results to files at every output time */
if (cData.res_out == 1) {FPrintY(mData, CV_Y, t, res_state_file);}
if (cData.flux_out == 1) {FPrintFlux(mData, t, res_flux_file);}
if (cData.etis_out == 1) {FPrintETIS(mData, t, res_etis_file);}
if (cData.q_out == 1) {FPrintQ(mData, t, res_q_file);}
if (cData.Verbose != 1) {printf("\r");}
if(flag != SUCCESS) {printf("CVode failed, flag = %d. \n", flag); return(flag);}
/* clear buffer */
fflush(stdout);
}
/* free memory */
/*
N_VFree(CV_Y);
CVodeFree(cvode_mem);
M_EnvFree_Serial(machEnv);
*/
/* capture time */
end_s = clock();
cputime_s = (end_s - end_r)/(realtype)CLOCKS_PER_SEC;
/* print out simulation statistics */
PrintFarewell(cData, iopt, ropt, cputime_r, cputime_s);
if (cData.res_out == 1) {FPrintFarewell(cData, res_state_file, iopt, ropt, cputime_r, cputime_s);}
/* close output files */
if (cData.res_out == 1) {fclose(res_state_file);}
if (cData.flux_out == 1) {fclose(res_flux_file);}
if (cData.etis_out == 1) {fclose(res_etis_file);}
if (cData.q_out == 1) {fclose(res_q_file);}
free(mData);
return 0;
}
int main(int argc, char **argv){
long j, p;
int pos, last, flushpos;
#ifdef __LUNA_DEBUG
clock_t start, end;
#endif
struct Dhash* DHash;
struct mallinfo MI;
struct list * liste;
DNAhash hashliste;
#ifdef __LUNA_DEBUG
start = clock();
#endif
CommandLine(argc, argv);
// reading the sequence from stdin.
p = 0;
f1 = FastaIn();
f2 = FastaIn();
hashliste = MakeDNAhash(klgde);
if (SeqLgth > 100000)
flushpos = 10000;
else
flushpos = SeqLgth / 100;
if (flushpos<100)
flushpos = 100;
printf("%s : Sequence length : %-7ld Tuble : %2d Gap: %2d",
ProgramName, p, klgde, gap - klgde);
if (Insert)
printf(" Insert : %d", Insert);
printf("\nComparing sequences : \n\t%s (%d)\n\t%s (%d)\n",
f1->navn,
f1->length,
f2->navn,
f2->length);
// find the longest string ...
//p = (f1->length>f2->length) ? f1->length : f2->length;
p = f1->length;
DHash = MakeDHash(p);
last = 0;
DistMin = 0;
if (verbose)
fprintf(stderr, "Building k-probe database\n");
for (j = 0; j < p - klgde; j+=klgde - back) {
liste = 0;
pos = FetchDNA(&f1->seq[j]);
if (pos == -1)
continue;
hashliste[pos] = insertNode(hashliste[pos]);
hashliste[pos]->start = j;
if (verbose)
if ((!(j % 1)) &&
((j * 100 / p) != last)) {
last = (j * 100 /p);
fprintf(stderr, "\rBuilding : %d %%", last);
fflush(stderr);
}
}
if (verbose)
fprintf(stderr, "\rBuilding : 100 %% .... Done\n");
//Sammen ligningen del 2.
//p = (f1->length>f2->length) ? f1->length : f2->length; //f2->length;
p = f2->length;
if (p > 100000)
flushpos = 10000;
else
flushpos = p / 100;
if (verbose)
fprintf(stderr, "Finding inverted repeats\n");
for (j = 0; j < p - klgde; j+=klgde - back) {
liste = 0;
pos = FetchDNA(&f2->seq[j]);
if (pos == -1)
continue;
liste = hashliste[pos];
HashCalcDistGar(DHash, liste, j);
// Let me show you my hash signs while I work
if (!(j % flushpos)) {
last = (j * 100 / p);
if (verbose)
fprintf(stderr, "\rProgress : %d %%", last);
DHashFlush(DHash, j);
}
}
if (verbose)
fprintf(stderr, "\rProgress : 100 %%\n");
DHashLastFlush(DHash);
printf("\n\n");
// So You wanna know the time and memory usage well... verbose we are.
if (verbose) {
PrintVerbose();
#ifdef __LUNA_DEBUG
end = clock();
fprintf(stderr, "Runtime %.2f sec\n", (double) (end - start) / CLOCKS_PER_SEC);
#endif
MI = mallinfo();
fprintf(stdout, "Allocated memory : %d kilobytes\n" ,
(MI.uordblks + MI.usmblks) / 1024);
}
return(0);
}
// Reads the data and serializes it into the message. This function does custom serialization for the same
// reason and with the same alrogithm as DeserializeAndWriteMessage.
HRESULT CFileRepServer::ReadAndSendChunk(
__in CRequest* request,
__in long chunkSize,
__in LONGLONG chunkPosition,
__in HANDLE file)
{
PrintVerbose(L"Entering CFileRepServer::ReadAndSendChunk");
if (chunkSize < 0 || chunkPosition < 0)
{
PrintVerbose(L"Leaving CFileRepServer::ReadAndSendChunk");
return E_INVALIDARG;
}
HRESULT hr = S_OK;
WS_XML_WRITER* writer = NULL;
WS_MESSAGE* replyMessage = request->GetReplyMessage();
WS_MESSAGE* requestMessage = request->GetRequestMessage();
WS_ERROR* error = request->GetError();
WS_CHANNEL* channel = request->GetChannel();
BYTE* buf = NULL;
LONG length = 0;
// To avoid using too much memory we read and write the message in chunks.
LONG bytesToRead = FILE_CHUNK;
if (bytesToRead > chunkSize)
{
bytesToRead = chunkSize;
}
buf = (BYTE*)HeapAlloc(GetProcessHeap(), 0, bytesToRead);
IfNullExit(buf);
IfFailedExit(WsInitializeMessage(replyMessage, WS_BLANK_MESSAGE, requestMessage, error));
// Add the action header
IfFailedExit(WsSetHeader(
replyMessage,
WS_ACTION_HEADER,
WS_XML_STRING_TYPE,
WS_WRITE_REQUIRED_VALUE,
&fileReplyAction,
sizeof(fileReplyAction),
error));
// Send the message headers
IfFailedExit(WsWriteMessageStart(channel, replyMessage, NULL, error));
// Get writer to serialize message body
IfFailedExit(WsGetMessageProperty(replyMessage, WS_MESSAGE_PROPERTY_BODY_WRITER, &writer, sizeof(writer), error));
// Write FileChunk start element.
// This whole code block is the serialization equivalent of the desiralization code.
IfFailedExit(WsWriteStartElement(writer, NULL, &fileChunkLocalName, &fileChunkNamespace, error));
// Write chunkPosition element
IfFailedExit(WsWriteStartElement(writer, NULL, &chunkPositionLocalName, &fileChunkNamespace, error));
IfFailedExit(WsWriteValue(writer, WS_INT64_VALUE_TYPE, &chunkPosition, sizeof(chunkPosition), error));
IfFailedExit(WsWriteEndElement(writer, error));
// Write fileContent start element
IfFailedExit(WsWriteStartElement(writer, NULL, &fileContentLocalName, &fileChunkNamespace, error));
// Like in the deserialization code, we read the file in multiple steps to avoid
// having to have everything in memory at once. The message could potentially be
// big so this is more efficient.
for (;;)
{
ULONG bytesRead = 0;
if (length + bytesToRead > chunkSize)
{
bytesToRead = chunkSize - length;
}
if (!ReadFile(file, buf, bytesToRead, &bytesRead, NULL))
{
PrintError(L"File read error.", true);
hr = HRESULT_FROM_WIN32(GetLastError());
EXIT_FUNCTION
}
if (0 == bytesRead)
{
// We reched the end of the file before filling the chunk. Send a partial chunk.
break;
}
IfFailedExit(WsWriteBytes(writer, buf, bytesRead, error));
length += bytesRead;
if (length == chunkSize)
{
// We filled the message
break;
}
}
// Performs the actual file transfer.
// This function will fail to produce a valid file on the client if the file was changed in between requests for chunks.
// There are ways to work around that, but doing so is beyond the scope of this version of the sample. A simple fix would be
// to keep the file open between requests and prevent writing, but in the spirit of web services this app does not maintain
// state between requests.
HRESULT CFileRepServer::ReadAndSendFile(
__in CRequest* request,
__in const LPWSTR fileName,
__in LONGLONG chunkPosition,
__in_opt WS_ERROR* error)
{
PrintVerbose(L"Entering CFileRepServer::ReadAndSendFile");
HANDLE file = NULL;
HRESULT hr = S_OK;
file = CreateFileW(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (INVALID_HANDLE_VALUE == file)
{
PrintInfo(L"Invalid file name");
if (-1 != chunkPosition)
{
hr = SendError(request, GlobalStrings::invalidFileName);
}
else
{
hr = SendFileInfo(request, fileName, -1, chunkSize);
}
PrintVerbose(L"Leaving CFileRepServer::ReadAndSendFile");
return hr;
}
LARGE_INTEGER len;
if (!GetFileSizeEx(file, &len))
{
hr = HRESULT_FROM_WIN32(GetLastError());
PrintError(L"Unable to determine file length", true);
if (FAILED(SendError(request, GlobalStrings::unableToDetermineFileLength)))
{
PrintError(L"Unable to send failure back", true);
}
if (!CloseHandle(file))
{
PrintError(L"Unable to close file handle", true);
}
// This has its own return path to ensure that the right error info is returned.
// The main error path would overwrite it.
PrintVerbose(L"Leaving CFileRepServer::ReadAndSendFile");
return hr;
}
LONGLONG fileLength = len.QuadPart;
if (chunkPosition == DISCOVERY_REQUEST)
{
PrintInfo(L"Processing discovery message");
hr = SendFileInfo(request, fileName, fileLength, chunkSize);
}
else if (chunkPosition < -1)
{
PrintInfo(L"Invalid request");
hr = SendError(request, GlobalStrings::invalidRequest);
}
else if (chunkPosition >= fileLength)
{
PrintInfo(L"Request out of range of the file");
hr = SendError(request, GlobalStrings::outOfRange);
}
else
{
long chunkSize = this->chunkSize;
if (fileLength - chunkPosition < chunkSize)
{
chunkSize = (DWORD)(fileLength - chunkPosition);
}
LARGE_INTEGER pos;
pos.QuadPart = chunkPosition;
if (!SetFilePointerEx(file, pos, NULL, FILE_BEGIN))
{
PrintError(L"Unable to set file pointer", true);
hr = E_FAIL;
// Ignore return value as we already have a failure.
SendError(request, GlobalStrings::unableToSetFilePointer);
}
else
{
hr = ReadAndSendChunk(request, chunkSize, chunkPosition, file);
}
}
if (FAILED(hr))
{
PrintError(L"CFileRepServer::ReadAndSendFile\n", true);
PrintError(hr, error, true);
}
if (!CloseHandle(file))
{
hr = HRESULT_FROM_WIN32(GetLastError());
PrintError(L"Unable to close file handle", true);
}
PrintVerbose(L"Leaving CFileRepServer::ReadAndSendFile");
return hr;
}
void PruneLinedefs(void)
{
int i;
int new_num;
DisplayTicker();
// scan all linedefs
for (i=0, new_num=0; i < num_linedefs; i++)
{
linedef_t *L = lev_linedefs[i];
// handle duplicated vertices
while (L->start->equiv)
{
L->start->ref_count--;
L->start = L->start->equiv;
L->start->ref_count++;
}
while (L->end->equiv)
{
L->end->ref_count--;
L->end = L->end->equiv;
L->end->ref_count++;
}
// handle duplicated sidedefs
while (L->right && L->right->equiv)
{
L->right->ref_count--;
L->right = L->right->equiv;
L->right->ref_count++;
}
while (L->left && L->left->equiv)
{
L->left->ref_count--;
L->left = L->left->equiv;
L->left->ref_count++;
}
// remove zero length lines
if (L->zero_len)
{
L->start->ref_count--;
L->end->ref_count--;
UtilFree(L);
continue;
}
L->index = new_num;
lev_linedefs[new_num++] = L;
}
if (new_num < num_linedefs)
{
PrintVerbose("Pruned %d zero-length linedefs\n", num_linedefs - new_num);
num_linedefs = new_num;
}
if (new_num == 0)
FatalError("Couldn't find any Linedefs");
}
/*
* ======== main ========
*/
INT main(INT argc, CHAR * argv[])
{
INT opt;
bool fWaitForTerminate = false;
UINT uProcId = 0; /* default proc ID is 0. */
bool fError = false;
DSP_HPROCESSOR hProc;
int status = 0;
INT cArgc = 0; /* local argc count. */
bool fScriptable = false;
extern char *optarg;
struct DSP_PROCESSORINFO dspInfo;
UINT numProcs;
UINT index = 0;
while ((opt = getopt(argc, argv, "+T+v+w+?p:")) != EOF) {
switch (opt) {
case 'v':
/* verbose mode */
fprintf(stdout, "Verbose mode: ON\n");
g_fVerbose = true;
cArgc++;
break;
case 'w':
/* wait for user input to terminate */
fprintf(stdout, "Not supported \n");
fWaitForTerminate = true;
cArgc++;
break;
case 'T':
fScriptable = true;
cArgc++;
break;
case 'p':
/* user specified DSP processor ID (based on zero-index) */
uProcId = atoi(optarg);
cArgc++;
break;
case '?':
default:
fError = true;
break;
}
}
argv += cArgc + 1;
argc -= cArgc + 1;
if (fError) {
DisplayUsage();
} else {
status = (DBAPI)DspManager_Open(ROOT_ACCESS, NULL);
if (DSP_FAILED(status)) {
PrintVerbose("DSPManager_Open failed \n");
return -1;
}
while (DSP_SUCCEEDED(DSPManager_EnumProcessorInfo(index,&dspInfo,
(UINT)sizeof(struct DSP_PROCESSORINFO),&numProcs))) {
if ((dspInfo.uProcessorType == DSPTYPE_55) ||
(dspInfo.uProcessorType == DSPTYPE_64)) {
printf("DSP device detected !! \n");
uProcId = index;
status = 0;
break;
}
index++;
}
status = DSPProcessor_Attach(uProcId, NULL, &hProc);
if (DSP_SUCCEEDED(status)) {
PrintVerbose("DSPProcessor_Attach succeeded.\n");
status = DSPProcessor_Stop(hProc);
if (DSP_SUCCEEDED(status)) {
PrintVerbose("DSPProcessor_Stop succeeded.\n");
status = DSPProcessor_Load(hProc,argc,(CONST CHAR **)argv,NULL);
if (DSP_SUCCEEDED(status)) {
PrintVerbose("DSPProcessor_Load succeeded.\n");
status = DSPProcessor_Start(hProc);
if (DSP_SUCCEEDED(status)) {
fprintf(stdout,"DSPProcessor_Start succeeded.\n");
#if 0
/* It seems Linux bridge does n't yet support
* * DSPProcessor_GetTrace */
if (fWaitForTerminate) {
/* wait for user */
fprintf(stdout,"Hit \"return\" to stop DSP and"
"dump trace buffer:\n");
(void)getchar();
status = DSPProcessor_GetTrace(hProc,
(BYTE *)&traceBuf,MAXTRACESIZE);
fprintf(stdout,"%s\n",traceBuf);
} else {
PrintVerbose("in run free mode...\n");
}
#endif /* 0 */
} else {
PrintVerbose("DSPProcessor_Start failed: 0x%x.\n",
status);
}
} else {
PrintVerbose("DSPProcessor_Load failed: 0x%x.\n",status);
}
DSPProcessor_Detach(hProc);
}
} else {
PrintVerbose("DSPProcessor_Attach failed: 0x%x.\n",status);
}
}
if (!fScriptable) {
/* Wait for user to hit any key before exiting. */
fprintf(stdout, "Hit any key to terminate cexec.\n");
(void)getchar();
}
status = DspManager_Close(0, NULL);
if (DSP_FAILED(status)) {
printf("\nERROR: DSPManager Close FAILED\n");
}
return (DSP_SUCCEEDED(status) ? 0 : -1);
}
int main(int argc, char **argv)
{
int i, j, k, treeNo, sumLength;
char ch;
TTree **treeSet;
FILE *text_fv;
clock_t totalStart;
double totalSecs, scale, sum;
char *ancestor;
totalStart = clock();
ReadParams(argc, argv);
if (rateHetero == CodonRates && invariableSites) {
fprintf(stderr, "Invariable sites model cannot be used with codon rate heterogeneity.\n");
exit(4);
}
if (writeAncestors && fileFormat == NEXUSFormat) {
fprintf(stderr, "Warning - When writing ancestral sequences, relaxed PHYLIP format is used.\n");
}
if (writeAncestors && maxPartitions > 1) {
fprintf(stderr, "Writing ancestral sequences can only be used for a single partition.\n");
exit(4);
}
if (!userSeed)
randomSeed = CreateSeed();
SetSeed(randomSeed);
if (!quiet)
PrintTitle();
numTrees = OpenTreeFile();
/* if (!treeFile) { */
ReadFileParams();
/*} */
if ((ancestorSeq>0 && !hasAlignment) || ancestorSeq>numSequences) {
fprintf(stderr, "Bad ancestral sequence number: %d (%d sequences loaded)\n", ancestorSeq, numSequences);
exit(4);
}
if (textFile) {
if ( (text_fv=fopen(textFileName, "rt"))==NULL ) {
fprintf(stderr, "Error opening text file for insertion into output: '%s'\n", textFileName);
exit(4);
}
}
ancestor=NULL;
if (hasAlignment) {
AllocateMemory();
ReadFile();
if (numSites<0)
numSites=numAlignmentSites;
if (ancestorSeq>0) {
if (numSites!=numAlignmentSites) {
fprintf(stderr, "Ancestral sequence is of a different length to the simulated sequences (%d)\n", numAlignmentSites);
exit(4);
}
ancestor=sequences[ancestorSeq-1];
}
} else if (numSites<0)
numSites=1000;
SetModel(model);
numTaxa=-1;
scale=1.0;
treeSet = (TTree **)malloc(sizeof(TTree **) * maxPartitions);
if (treeSet==NULL) {
fprintf(stderr, "Out of memory\n");
exit(5);
}
partitionLengths = (int *)malloc(sizeof(int) * maxPartitions);
if (partitionLengths==NULL) {
fprintf(stderr, "Out of memory\n");
exit(5);
}
partitionRates = (double *)malloc(sizeof(double) * maxPartitions);
if (partitionRates==NULL) {
fprintf(stderr, "Out of memory\n");
exit(5);
}
for (i = 0; i < maxPartitions; i++) {
if ((treeSet[i]=NewTree())==NULL) {
fprintf(stderr, "Out of memory\n");
exit(5);
}
}
CreateRates();
treeNo=0;
do {
partitionLengths[0] = -1;
ReadTree(tree_fv, treeSet[0], treeNo+1, 0, NULL, &partitionLengths[0], &partitionRates[0]);
if (treeNo==0) {
numTaxa=treeSet[0]->numTips;
if (!quiet)
fprintf(stderr, "Random number generator seed: %ld\n\n", randomSeed);
if (fileFormat == NEXUSFormat) {
fprintf(stdout, "#NEXUS\n");
fprintf(stdout, "[\nGenerated by %s %s\n\n", PROGRAM_NAME, VERSION_NUMBER);
PrintVerbose(stdout);
fprintf(stdout, "]\n\n");
}
} else if (treeSet[0]->numTips != numTaxa) {
fprintf(stderr, "All trees must have the same number of tips.\n");
exit(4);
}
if (maxPartitions == 1) {
if (partitionLengths[0] != -1) {
fprintf(stderr, "\nWARNING: The treefile contained partion lengths but only one partition\n");
fprintf(stderr, "was specified.\n");
}
partitionLengths[0] = numSites;
}
sumLength = partitionLengths[0];
i = 1;
while (sumLength < numSites && i <= maxPartitions) {
if (!IsTreeAvail(tree_fv)) {
fprintf(stderr, "\nA set of trees number %d had less partition length (%d) than\n", treeNo + 1, sumLength);
fprintf(stderr, "was required to make a sequence of length %d.\n", numSites);
exit(4);
}
ReadTree(tree_fv, treeSet[i], treeNo+1, treeSet[0]->numTips, treeSet[0]->names,
&partitionLengths[i], &partitionRates[i]);
if (treeSet[i]->numTips != numTaxa) {
fprintf(stderr, "All trees must have the same number of tips.\n");
exit(4);
}
sumLength += partitionLengths[i];
i++;
}
if (i > maxPartitions) {
fprintf(stderr, "\nA set of trees number %d had more partitions (%d) than\n", treeNo + 1, i);
fprintf(stderr, "was specified in the user options (%d).\n", maxPartitions);
}
numPartitions = i;
if (sumLength != numSites) {
fprintf(stderr, "The sum of the partition lengths in the treefile does not equal\n");
fprintf(stderr, "the specified number of sites.\n");
exit(4);
}
for (i = 0; i < numPartitions; i++)
CreateSequences(treeSet[i], partitionLengths[i]);
if (numPartitions > 1) {
sum = 0.0;
for (i = 0; i < numPartitions; i++)
sum += partitionRates[i] * partitionLengths[i];
for (i = 0; i < numPartitions; i++)
partitionRates[i] *= numSites / sum;
}
if (treeNo==0 && verbose && !quiet) {
PrintVerbose(stderr);
InitProgressBar(numTrees*numDatasets);
DrawProgressBar();
}
for (i=0; i<numDatasets; i++) {
SetCategories();
k = 0;
for (j = 0; j < numPartitions; j++) {
scale = partitionRates[j];
if (scaleTrees) {
if (!treeSet[j]->rooted) {
fprintf(stderr, "To scale tree length, they must be rooted and ultrametric.\n");
exit(4);
}
scale *= treeScale/treeSet[j]->totalLength;
} else if (scaleBranches)
scale *= branchScale;
EvolveSequences(treeSet[j], k, partitionLengths[j], scale, ancestor);
k += partitionLengths[j];
}
if (writeAncestors)
WriteAncestralSequences(stdout, treeSet[0]);
else
WriteSequences(stdout, (numTrees > 1 ? treeNo+1 : -1), (numDatasets > 1 ? i+1 : -1), treeSet, partitionLengths);
if (writeRates) {
WriteRates(stderr);
}
if (textFile) {
while (!feof(text_fv)) {
ch = fgetc(text_fv);
if (!feof(text_fv))
fputc(ch, stdout);
}
fputc('\n', stdout);
rewind(text_fv);
}
if (verbose && !quiet)
ProgressBar();
}
for (i = 0; i < numPartitions; i++)
DisposeTree(treeSet[i]);
treeNo++;
} while (IsTreeAvail(tree_fv));
/* for (i = 0; i < maxPartitions; i++)
FreeTree(treeSet[i]); */
if (treeFile)
fclose(tree_fv);
if (textFile)
fclose(text_fv);
totalSecs = (double)(clock() - totalStart) / CLOCKS_PER_SEC;
if (!quiet) {
fprintf(stderr, "Time taken: %G seconds\n", totalSecs);
if (verboseMemory)
fprintf(stderr, "Total memory used: %ld\n", totalMem);
}
return 0;
}